debtmap 0.20.0

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

use debtmap::analyzers::rust_call_graph::extract_call_graph;
use std::path::PathBuf;

#[test]
fn test_real_complexity_refactoring_struct_literal() {
    // This test mirrors the exact structure from complexity_refactoring.rs
    let code = r#"
use crate::refactoring::{ExtractionStrategy, RefactoringOpportunity};

struct ComplexityRefactoring;

impl RefactoringDetector for ComplexityRefactoring {
    fn detect(&self, function: &FunctionMetrics) -> Vec<RefactoringOpportunity> {
        let functions_to_extract = 3;
        
        vec![RefactoringOpportunity {
            extraction_strategy: ExtractionStrategy::DirectFunctionalTransformation {
                patterns_to_apply: vec![
                    FunctionalPattern::MapOverLoop,
                    FunctionalPattern::FilterPredicate,
                ],
                functions_to_extract,
            },
            suggested_functions: generate_suggested_functions(
                &function.name,
                functions_to_extract,
            ),
            functional_patterns: vec![
                FunctionalPattern::MapOverLoop,
                FunctionalPattern::FilterPredicate,
                FunctionalPattern::ComposeFunctions,
            ],
        }]
    }
}

fn generate_suggested_functions(base_name: &str, count: u32) -> Vec<PureFunctionSpec> {
    let mut functions = Vec::new();
    
    if count > 0 {
        functions.push(PureFunctionSpec {
            name: format!("{}_validate", base_name),
        });
    }
    
    functions
}
    "#;

    let syntax = syn::parse_file(code).expect("Failed to parse code");
    let path = PathBuf::from("test.rs");
    let call_graph = extract_call_graph(&syntax, &path);

    // Find the actual function IDs from the graph
    let all_functions = call_graph.find_all_functions();

    println!("All functions found:");
    for func in &all_functions {
        println!("  {:?}", func);
    }

    // Find generate_suggested_functions
    let generate_id = all_functions
        .iter()
        .find(|f| f.name == "generate_suggested_functions")
        .expect("generate_suggested_functions should be in the graph");

    // Check that it has callers
    let callers = call_graph.get_callers(generate_id);
    println!("Callers of generate_suggested_functions: {:?}", callers);

    assert!(
        !callers.is_empty(),
        "generate_suggested_functions should have callers, but has none"
    );
}

#[test]
fn test_vec_macro_with_struct_literal() {
    // Test with vec! macro containing struct literal
    let code = r#"
struct RefactoringOpportunity {
    suggested_functions: Vec<String>,
}

fn detect() -> Vec<RefactoringOpportunity> {
    vec![RefactoringOpportunity {
        suggested_functions: generate_functions("base", 3),
    }]
}

fn generate_functions(base_name: &str, count: u32) -> Vec<String> {
    vec![format!("{}_validate", base_name)]
}
    "#;

    let syntax = syn::parse_file(code).expect("Failed to parse code");
    let path = PathBuf::from("test.rs");
    let call_graph = extract_call_graph(&syntax, &path);

    let all_functions = call_graph.find_all_functions();

    println!("Functions in vec! macro test:");
    for func in &all_functions {
        println!("  {:?}", func);
    }

    let detect_id = all_functions
        .iter()
        .find(|f| f.name == "detect")
        .expect("detect should be in the graph")
        .clone();

    let generate_id = all_functions
        .iter()
        .find(|f| f.name == "generate_functions")
        .expect("generate_functions should be in the graph")
        .clone();

    // Check the calls
    let calls_from_detect = call_graph.get_callees(&detect_id);
    println!("Calls from detect: {:?}", calls_from_detect);

    assert!(
        calls_from_detect.contains(&generate_id),
        "detect should call generate_functions"
    );

    // Check that generate_functions has callers
    let callers = call_graph.get_callers(&generate_id);
    assert!(
        !callers.is_empty(),
        "generate_functions should have callers"
    );
}