debtmap 0.16.3

Code complexity and technical debt analyzer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::priority::UnifiedDebtItem;
use colored::*;
use std::fmt::Write;

/// Format complexity summary line
pub fn format_complexity_summary(
    output: &mut String,
    item: &UnifiedDebtItem,
    _formatter: &crate::formatting::ColoredFormatter,
) {
    let (cyclomatic, cognitive, branch_count, nesting, _length) =
        crate::priority::formatter::extract_complexity_info(item);

    if cyclomatic > 0 || cognitive > 0 {
        if let Some(ref entropy) = item.entropy_analysis {
            writeln!(
                output,
                "├─ {} cyclomatic={} (dampened: {}, factor: {:.2}), est_branches={}, cognitive={}, nesting={}, entropy={:.2}",
                "COMPLEXITY:".bright_blue(),
                cyclomatic.to_string().yellow(),
                entropy.adjusted_complexity.to_string().yellow(),
                entropy.dampening_factor,
                branch_count.to_string().yellow(),
                cognitive.to_string().yellow(),
                nesting.to_string().yellow(),
                entropy.entropy_score
            )
            .unwrap();
        } else {
            writeln!(
                output,
                "├─ {} cyclomatic={}, est_branches={}, cognitive={}, nesting={}",
                "COMPLEXITY:".bright_blue(),
                cyclomatic.to_string().yellow(),
                branch_count.to_string().yellow(),
                cognitive.to_string().yellow(),
                nesting.to_string().yellow()
            )
            .unwrap();
        }
    }
}

/// Format pattern detection for state machine and coordinator patterns (spec 204)
/// Reads from item.detected_pattern (single source of truth) instead of re-detecting
pub fn format_pattern_detection(output: &mut String, item: &UnifiedDebtItem) {
    // Read stored pattern result instead of re-detecting
    if let Some(ref pattern) = item.detected_pattern {
        let metrics_str = pattern.display_metrics().join(", ");

        writeln!(
            output,
            "├─ {} {} {} ({}, confidence: {:.2})",
            "PATTERN:".bright_blue(),
            pattern.icon(),
            pattern.type_name().bright_magenta().bold(),
            metrics_str.cyan(),
            pattern.confidence
        )
        .unwrap();
    }
}

/// Pure function to classify complexity contribution
pub fn classify_complexity_contribution(complexity_factor: f64) -> &'static str {
    match complexity_factor {
        c if c > 10.0 => "VERY HIGH",
        c if c > 5.0 => "HIGH",
        c if c > 3.0 => "MEDIUM",
        _ => "LOW",
    }
}

/// Format complexity details section
pub fn format_complexity_details_section(
    item: &UnifiedDebtItem,
    _formatter: &crate::formatting::ColoredFormatter,
) -> Vec<String> {
    let mut lines = Vec::new();
    let tree_pipe = " ";

    lines.push(format!("{} {}", "-", "COMPLEXITY DETAILS:".bright_blue()));

    // Format cyclomatic complexity with entropy dampening if available
    if let Some(ref entropy) = item.entropy_analysis {
        lines.push(format!(
            "{}  {} cyclomatic={} (dampened: {}, factor: {:.2})",
            tree_pipe,
            "-",
            item.cyclomatic_complexity,
            entropy.adjusted_complexity,
            entropy.dampening_factor
        ));
    } else {
        lines.push(format!(
            "{}  {} cyclomatic={}",
            tree_pipe, "-", item.cyclomatic_complexity
        ));
    }

    lines.push(format!(
        "{}  {} cognitive={}",
        tree_pipe, "-", item.cognitive_complexity
    ));

    lines.push(format!(
        "{}  {} Function Length: {} lines",
        tree_pipe, "-", item.function_length
    ));

    lines.push(format!(
        "{}  {} Nesting Depth: {}",
        tree_pipe, "-", item.nesting_depth
    ));

    lines
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_classify_complexity_contribution() {
        assert_eq!(classify_complexity_contribution(15.0), "VERY HIGH");
        assert_eq!(classify_complexity_contribution(10.1), "VERY HIGH");
        assert_eq!(classify_complexity_contribution(10.0), "HIGH");
        assert_eq!(classify_complexity_contribution(7.0), "HIGH");
        assert_eq!(classify_complexity_contribution(5.1), "HIGH");
        assert_eq!(classify_complexity_contribution(5.0), "MEDIUM");
        assert_eq!(classify_complexity_contribution(4.0), "MEDIUM");
        assert_eq!(classify_complexity_contribution(3.1), "MEDIUM");
        assert_eq!(classify_complexity_contribution(3.0), "LOW");
        assert_eq!(classify_complexity_contribution(1.0), "LOW");
    }
}