debtmap 0.17.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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Module Structure Analysis
//!
//! Provides detailed analysis of module structure including:
//! - Accurate function counting (module-level, impl methods, trait methods)
//! - Component detection (structs, enums, impl blocks)
//! - Responsibility identification
//! - Coupling analysis for refactoring recommendations
//! - Facade detection for well-organized modules (Spec 170)
//!
//! ## Architecture
//!
//! This module is organized following the Stillwater philosophy:
//! - `types`: Pure data types and their core operations
//! - `rust_analyzer`: Rust-specific analysis using `syn`
//! - `python_analyzer`: Python analysis via pattern matching
//! - `js_analyzer`: JavaScript/TypeScript analysis via pattern matching
//! - `facade`: Module facade detection logic
//!
//! ## Usage
//!
//! ```ignore
//! use debtmap::analysis::module_structure::ModuleStructureAnalyzer;
//!
//! let analyzer = ModuleStructureAnalyzer::new_rust();
//! let structure = analyzer.analyze_rust_file(content, path);
//! ```

mod facade;
mod js_analyzer;
mod python_analyzer;
mod rust_analyzer;
mod types;

// Re-export all public types
pub use facade::{classify_organization_quality, extract_path_attribute};
pub use types::{
    ComponentCouplingAnalysis, ComponentDependencyGraph, Difficulty, FunctionCounts, FunctionGroup,
    ModuleComponent, ModuleFacadeInfo, ModuleStructure, OrganizationQuality, PathDeclaration,
    SplitRecommendation,
};

// Re-export pure helper functions
pub use types::{difficulty_from_coupling, suggest_module_name};

/// Module structure analyzer supporting multiple languages
///
/// Provides a unified interface for analyzing module structure across
/// Rust, Python, JavaScript, and TypeScript files.
pub struct ModuleStructureAnalyzer {
    _language: String, // For future multi-language support
}

impl ModuleStructureAnalyzer {
    pub fn new_rust() -> Self {
        Self {
            _language: "rust".to_string(),
        }
    }

    pub fn new_python() -> Self {
        Self {
            _language: "python".to_string(),
        }
    }

    pub fn new_javascript() -> Self {
        Self {
            _language: "javascript".to_string(),
        }
    }

    pub fn new_typescript() -> Self {
        Self {
            _language: "typescript".to_string(),
        }
    }

    /// Analyze a Rust source file to extract detailed module structure
    pub fn analyze_rust_file(&self, content: &str, file_path: &std::path::Path) -> ModuleStructure {
        rust_analyzer::analyze_rust_file(content, file_path)
    }

    /// Analyze a parsed Rust AST directly
    pub fn analyze_rust_ast(&self, ast: &syn::File) -> ModuleStructure {
        rust_analyzer::analyze_rust_ast(ast)
    }

    /// Analyze a Python source file to extract module structure
    pub fn analyze_python_file(
        &self,
        content: &str,
        file_path: &std::path::Path,
    ) -> ModuleStructure {
        python_analyzer::analyze_python_file(content, file_path)
    }

    /// Analyze a JavaScript source file to extract module structure
    pub fn analyze_javascript_file(
        &self,
        content: &str,
        file_path: &std::path::Path,
    ) -> ModuleStructure {
        js_analyzer::analyze_javascript_file(content, file_path)
    }

    /// Analyze a TypeScript source file to extract module structure
    pub fn analyze_typescript_file(
        &self,
        content: &str,
        file_path: &std::path::Path,
    ) -> ModuleStructure {
        js_analyzer::analyze_typescript_file(content, file_path)
    }
}

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

    #[test]
    fn test_analyzer_creation() {
        let _rust = ModuleStructureAnalyzer::new_rust();
        let _python = ModuleStructureAnalyzer::new_python();
        let _js = ModuleStructureAnalyzer::new_javascript();
        let _ts = ModuleStructureAnalyzer::new_typescript();
    }

    #[test]
    fn test_analyze_simple_rust_file() {
        let code = r#"
            pub struct Foo {
                field: u32,
            }

            impl Foo {
                pub fn new() -> Self {
                    Self { field: 0 }
                }
            }

            pub fn helper() {}
        "#;

        let analyzer = ModuleStructureAnalyzer::new_rust();
        let structure = analyzer.analyze_rust_file(code, std::path::Path::new("test.rs"));

        assert_eq!(structure.function_counts.impl_methods, 1);
        assert_eq!(structure.function_counts.module_level_functions, 1);
        assert!(structure.responsibility_count >= 1);
    }
}