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
158
159
160
161
162

use serde::{Deserialize, Serialize};

use super::{AccessorDetectionConfig, ConstructorDetectionConfig, DataFlowClassificationConfig};

/// Configuration for caller/callee display in output
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct CallerCalleeConfig {
    /// Maximum number of callers to display (default: 5)
    #[serde(default = "default_max_callers")]
    pub max_callers: usize,

    /// Maximum number of callees to display (default: 5)
    #[serde(default = "default_max_callees")]
    pub max_callees: usize,

    /// Whether to show external crate calls (default: false)
    #[serde(default = "default_show_external")]
    pub show_external: bool,

    /// Whether to show standard library calls (default: false)
    #[serde(default = "default_show_std_lib")]
    pub show_std_lib: bool,
}

impl Default for CallerCalleeConfig {
    fn default() -> Self {
        Self {
            max_callers: default_max_callers(),
            max_callees: default_max_callees(),
            show_external: default_show_external(),
            show_std_lib: default_show_std_lib(),
        }
    }
}

fn default_max_callers() -> usize {
    5
}

fn default_max_callees() -> usize {
    5
}

fn default_show_external() -> bool {
    false
}

fn default_show_std_lib() -> bool {
    false
}

/// Context-aware detection configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContextConfig {
    /// Whether context-aware detection is enabled
    #[serde(default = "default_context_enabled")]
    pub enabled: bool,

    /// Custom context rules
    #[serde(default)]
    pub rules: Vec<ContextRuleConfig>,

    /// Function role patterns
    #[serde(default)]
    pub function_patterns: Option<FunctionPatternConfig>,
}

impl Default for ContextConfig {
    fn default() -> Self {
        Self {
            enabled: default_context_enabled(),
            rules: Vec::new(),
            function_patterns: None,
        }
    }
}

fn default_context_enabled() -> bool {
    false // Opt-in by default
}

/// Configuration for a context rule
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContextRuleConfig {
    /// Name of the rule
    pub name: String,

    /// Pattern to match (e.g., "blocking_io", "security", "performance")
    pub pattern: String,

    /// Context matcher configuration
    pub context: ContextMatcherConfig,

    /// Action to take (allow, skip, warn, reduce_severity)
    pub action: String,

    /// Priority (higher number = higher priority)
    #[serde(default = "default_rule_priority")]
    pub priority: i32,

    /// Optional reason for the rule
    pub reason: Option<String>,
}

fn default_rule_priority() -> i32 {
    50
}

/// Context matcher configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContextMatcherConfig {
    /// Function role (main, test, handler, config_loader, etc.)
    pub role: Option<String>,

    /// File type (production, test, benchmark, example, etc.)
    pub file_type: Option<String>,

    /// Whether function is async
    pub is_async: Option<bool>,

    /// Framework pattern (rust_main, web_handler, cli_handler, etc.)
    pub framework_pattern: Option<String>,

    /// Function name pattern (regex)
    pub name_pattern: Option<String>,
}

/// Function pattern configuration for detection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionPatternConfig {
    /// Additional test function patterns
    #[serde(default)]
    pub test_patterns: Vec<String>,

    /// Additional config loader patterns
    #[serde(default)]
    pub config_patterns: Vec<String>,

    /// Additional handler patterns
    #[serde(default)]
    pub handler_patterns: Vec<String>,

    /// Additional initialization patterns
    #[serde(default)]
    pub init_patterns: Vec<String>,
}

/// Classification configuration
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ClassificationConfig {
    /// Constructor detection configuration
    #[serde(default)]
    pub constructors: Option<ConstructorDetectionConfig>,

    /// Accessor detection configuration (spec 125)
    #[serde(default)]
    pub accessors: Option<AccessorDetectionConfig>,

    /// Data flow classification configuration (spec 126)
    #[serde(default)]
    pub data_flow: Option<DataFlowClassificationConfig>,
}