archmap 1.0.2

Static architectural analysis of codebases.
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

use crate::config::Config;
use crate::model::{DefinitionKind, Issue, Module};

pub fn detect_god_objects(modules: &[Module], config: &Config) -> Vec<Issue> {
    let mut issues = Vec::new();

    for module in modules {
        if module.lines < config.thresholds.god_object_lines {
            continue;
        }

        // Detect mixed responsibilities
        let responsibilities = detect_responsibilities(module);

        if responsibilities.len() > 1 {
            issues.push(Issue::god_object(
                module.path.clone(),
                module.lines,
                responsibilities,
            ));
        }
    }

    issues
}

fn detect_responsibilities(module: &Module) -> Vec<String> {
    let mut responsibilities = Vec::new();

    let has_structs = module
        .definitions
        .iter()
        .any(|d| d.kind == DefinitionKind::Struct);
    let has_functions = module
        .definitions
        .iter()
        .any(|d| d.kind == DefinitionKind::Function);
    let has_traits = module
        .definitions
        .iter()
        .any(|d| d.kind == DefinitionKind::Trait);
    let has_impls = module
        .definitions
        .iter()
        .any(|d| d.kind == DefinitionKind::Impl);

    // Count distinct types being implemented
    let impl_count = module
        .definitions
        .iter()
        .filter(|d| d.kind == DefinitionKind::Impl)
        .count();

    let struct_count = module
        .definitions
        .iter()
        .filter(|d| d.kind == DefinitionKind::Struct)
        .count();

    // Heuristics for responsibility detection
    if has_structs && struct_count > 3 {
        responsibilities.push(format!("data definitions ({} structs)", struct_count));
    }

    if has_functions {
        let fn_count = module
            .definitions
            .iter()
            .filter(|d| d.kind == DefinitionKind::Function)
            .count();
        if fn_count > 10 {
            responsibilities.push(format!("business logic ({} functions)", fn_count));
        }
    }

    if has_traits {
        responsibilities.push("trait definitions".to_string());
    }

    if has_impls && impl_count > 5 {
        responsibilities.push(format!("implementations ({} impls)", impl_count));
    }

    // If we couldn't detect specific responsibilities but it's still large
    if responsibilities.is_empty() && module.lines >= 500 {
        responsibilities.push("large module".to_string());
    }

    responsibilities
}