Struct ComplexityMetrics 

pub struct ComplexityMetrics {
    pub cyclomatic_complexity: u32,
    pub branches: u32,
    pub loops: u32,
    pub logical_operators: u32,
    pub max_nesting_depth: u32,
    pub exception_handlers: u32,
    pub early_returns: u32,
}

Complexity metrics for a function or method.

These metrics help identify code that may be difficult to understand, test, or maintain.

Fields

cyclomatic_complexity: u32

McCabe’s Cyclomatic Complexity (CC)

CC = 1 + number of decision points

• 1-5: Simple, low risk
• 6-10: Moderate complexity
• 11-20: Complex, moderate risk
• 21-50: Very complex, high risk
• 51+: Untestable, very high risk

branches: u32

Number of branch statements (if, else if, else, switch/match cases)

loops: u32

Number of loop constructs (for, while, loop, do-while)

logical_operators: u32

Number of logical operators (&& / || / and / or)

max_nesting_depth: u32

Maximum nesting depth of control structures

exception_handlers: u32

Number of exception handlers (catch, except, rescue)

early_returns: u32

Number of early returns (return statements not at the end)

Implementations

impl ComplexityMetrics

pub fn new() -> Self

Create a new ComplexityMetrics with default values (base complexity of 1)

pub fn calculate_cyclomatic(&mut self)

Calculate the cyclomatic complexity from the component counts

CC = 1 + branches + loops + logical_operators + exception_handlers

pub fn grade(&self) -> char

Get a letter grade based on cyclomatic complexity

• A: 1-5 (Simple, low risk)
• B: 6-10 (Moderate complexity)
• C: 11-20 (Complex, moderate risk)
• D: 21-50 (Very complex, high risk)
• F: 51+ (Untestable, very high risk)

pub fn exceeds_threshold(&self, threshold: u32) -> bool

Check if complexity exceeds a threshold

pub fn has_high_nesting(&self) -> bool

Check if the function has high nesting (> 4 levels)

pub fn merge_nested(&mut self, nested: &ComplexityMetrics)

Merge metrics from a nested scope (used when traversing nested functions)

pub fn with_branches(self, count: u32) -> Self

pub fn with_loops(self, count: u32) -> Self

pub fn with_logical_operators(self, count: u32) -> Self

pub fn with_nesting_depth(self, depth: u32) -> Self

pub fn with_exception_handlers(self, count: u32) -> Self

pub fn with_early_returns(self, count: u32) -> Self

pub fn finalize(self) -> Self

Finalize and calculate the cyclomatic complexity

Trait Implementations

impl Clone for ComplexityMetrics

fn clone(&self) -> ComplexityMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ComplexityMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ComplexityMetrics

fn default() -> ComplexityMetrics

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ComplexityMetrics

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ComplexityMetrics

fn eq(&self, other: &ComplexityMetrics) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ComplexityMetrics

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ComplexityMetrics