debtmap 0.16.4

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#[cfg(test)]
mod entropy_framework_tests {
    use debtmap::complexity::entropy_core::{
        EntropyConfig, EntropyToken, LanguageEntropyAnalyzer, PatternMetrics,
        UniversalEntropyCalculator,
    };
    use debtmap::complexity::entropy_traits::GenericToken;

    #[test]
    fn test_shannon_entropy_calculation() {
        let config = EntropyConfig::default();
        let calculator = UniversalEntropyCalculator::new(config);

        // Test with uniform distribution
        let tokens = vec![
            GenericToken::keyword("if".to_string()),
            GenericToken::identifier("var".to_string()),
            GenericToken::operator("=".to_string()),
            GenericToken::literal("42".to_string()),
        ];

        let entropy = calculator.shannon_entropy(&tokens);
        assert!(entropy > 0.0 && entropy <= 1.0);
    }

    #[test]
    fn test_entropy_with_no_tokens() {
        let config = EntropyConfig::default();
        let calculator = UniversalEntropyCalculator::new(config);

        let tokens: Vec<GenericToken> = vec![];
        let entropy = calculator.shannon_entropy(&tokens);
        assert_eq!(entropy, 0.0);
    }

    #[test]
    fn test_entropy_with_identical_tokens() {
        let config = EntropyConfig::default();
        let calculator = UniversalEntropyCalculator::new(config);

        // All tokens of same type - low entropy
        let tokens = vec![
            GenericToken::keyword("if".to_string()),
            GenericToken::keyword("while".to_string()),
            GenericToken::keyword("for".to_string()),
            GenericToken::keyword("match".to_string()),
        ];

        let entropy = calculator.shannon_entropy(&tokens);
        assert_eq!(entropy, 0.0); // All same category
    }

    #[test]
    fn test_complexity_adjustment() {
        let config = EntropyConfig::default();
        let calculator = UniversalEntropyCalculator::new(config);

        // Test with different pattern and similarity values
        let adjusted = calculator.adjust_complexity(0.8, 0.3, 0.2);
        assert!(adjusted > 0.0 && adjusted < 0.8);
    }

    #[test]
    fn test_pattern_metrics() {
        let mut metrics = PatternMetrics::new();
        metrics.total_patterns = 10;
        metrics.unique_patterns = 5;
        metrics.calculate_repetition();

        assert_eq!(metrics.repetition_ratio, 0.5);
    }

    #[test]
    fn test_token_category_equality() {
        let token1 = GenericToken::keyword("if".to_string());
        let token2 = GenericToken::keyword("else".to_string());

        // Same category but different value
        assert_eq!(
            EntropyToken::to_category(&token1),
            EntropyToken::to_category(&token2)
        );
    }

    #[test]
    fn test_token_weights() {
        let keyword = GenericToken::keyword("if".to_string());
        let literal = GenericToken::literal("42".to_string());
        let control_flow = GenericToken::control_flow("while".to_string());

        assert_eq!(EntropyToken::weight(&keyword), 1.0);
        assert_eq!(EntropyToken::weight(&literal), 0.3);
        assert_eq!(EntropyToken::weight(&control_flow), 1.2);
    }

    #[test]
    fn test_cache_functionality() {
        let config = EntropyConfig {
            enabled: true,
            max_cache_size: 2,
            base_threshold: 0.5,
            pattern_weight: 0.3,
            similarity_weight: 0.2,
        };
        let mut calculator = UniversalEntropyCalculator::new(config);

        // Mock analyzer for testing
        struct MockAnalyzer;
        impl LanguageEntropyAnalyzer for MockAnalyzer {
            type AstNode = String;
            type Token = GenericToken;

            fn extract_tokens(&self, _node: &Self::AstNode) -> Vec<Self::Token> {
                vec![GenericToken::keyword("test".to_string())]
            }

            fn detect_patterns(&self, _node: &Self::AstNode) -> PatternMetrics {
                PatternMetrics::new()
            }

            fn calculate_branch_similarity(&self, _node: &Self::AstNode) -> f64 {
                0.0
            }

            fn analyze_structure(&self, _node: &Self::AstNode) -> (usize, u32) {
                (0, 0)
            }

            fn generate_cache_key(&self, node: &Self::AstNode) -> String {
                node.clone()
            }
        }

        let analyzer = MockAnalyzer;
        let node1 = "function1".to_string();
        let node2 = "function2".to_string();

        // First call should miss cache
        let _score1 = calculator.calculate(&analyzer, &node1);
        let (hits, misses, _) = calculator.cache_stats();
        assert_eq!(hits, 0);
        assert_eq!(misses, 1);

        // Second call with same key should hit cache
        let _score1_again = calculator.calculate(&analyzer, &node1);
        let (hits, misses, _) = calculator.cache_stats();
        assert_eq!(hits, 1);
        assert_eq!(misses, 1);

        // Different key should miss cache
        let _score2 = calculator.calculate(&analyzer, &node2);
        let (hits, misses, hit_rate) = calculator.cache_stats();
        assert_eq!(hits, 1);
        assert_eq!(misses, 2);
        assert_eq!(hit_rate, 1.0 / 3.0);
    }
}