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

use super::{MaintainabilityImpact, OrganizationAntiPattern, OrganizationDetector};
use crate::common::{LocationConfidence, SourceLocation};
use crate::organization::struct_initialization::StructInitPatternDetector;
use syn::File;

pub struct StructInitOrganizationDetector {
    pattern_detector: StructInitPatternDetector,
}

impl StructInitOrganizationDetector {
    pub fn new() -> Self {
        Self {
            pattern_detector: StructInitPatternDetector::new(),
        }
    }
}

impl Default for StructInitOrganizationDetector {
    fn default() -> Self {
        Self::new()
    }
}

impl OrganizationDetector for StructInitOrganizationDetector {
    fn detect_anti_patterns(&self, file: &File) -> Vec<OrganizationAntiPattern> {
        let file_content = String::new(); // We'll need actual content for span analysis

        // For now, return empty vec since we need file content
        // In real integration, this will be provided via context
        if let Some(pattern) = self.pattern_detector.detect(file, &file_content) {
            let confidence = self.pattern_detector.confidence(&pattern);
            let field_complexity = self
                .pattern_detector
                .calculate_init_complexity_score(&pattern);
            let recommendation = self.pattern_detector.generate_recommendation(&pattern);

            // Only report if confidence is high enough
            if confidence >= 0.60 {
                let location = SourceLocation {
                    line: 1, // We'd extract from pattern in real impl
                    column: Some(0),
                    end_line: None,
                    end_column: None,
                    confidence: LocationConfidence::Approximate,
                };

                vec![OrganizationAntiPattern::StructInitialization {
                    function_name: pattern.struct_name.clone(),
                    struct_name: pattern.struct_name,
                    field_count: pattern.field_count,
                    cyclomatic_complexity: pattern.cyclomatic_complexity,
                    field_based_complexity: field_complexity,
                    confidence,
                    recommendation,
                    location,
                }]
            } else {
                vec![]
            }
        } else {
            vec![]
        }
    }

    fn detector_name(&self) -> &'static str {
        "StructInitializationDetector"
    }

    fn estimate_maintainability_impact(
        &self,
        pattern: &OrganizationAntiPattern,
    ) -> MaintainabilityImpact {
        if let OrganizationAntiPattern::StructInitialization {
            field_count,
            cyclomatic_complexity,
            confidence,
            ..
        } = pattern
        {
            // High confidence + high complexity = higher impact
            if *confidence > 0.80 && *cyclomatic_complexity > 30 {
                MaintainabilityImpact::High
            } else if *field_count > 40 {
                MaintainabilityImpact::Medium
            } else {
                MaintainabilityImpact::Low
            }
        } else {
            MaintainabilityImpact::Low
        }
    }
}