debtmap 0.18.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

use crate::analyzers::go::types::GoFunction;
use crate::core::Dependency;
use crate::core::{ComplexityMetrics, DebtItem, FileMetrics, FunctionMetrics, Language};
use std::path::PathBuf;

pub fn build_file_metrics(
    path: PathBuf,
    functions: Vec<FunctionMetrics>,
    debt_items: Vec<DebtItem>,
    dependencies: Vec<Dependency>,
    total_lines: usize,
) -> FileMetrics {
    let complexity = complexity_totals(functions);

    FileMetrics {
        path,
        language: Language::Go,
        complexity,
        debt_items,
        dependencies,
        duplications: vec![],
        total_lines,
        module_scope: None,
        classes: None,
    }
}

fn complexity_totals(functions: Vec<FunctionMetrics>) -> ComplexityMetrics {
    let cyclomatic_complexity = functions.iter().map(|f| f.cyclomatic).sum();
    let cognitive_complexity = functions.iter().map(|f| f.cognitive).sum();

    ComplexityMetrics {
        functions,
        cyclomatic_complexity,
        cognitive_complexity,
    }
}

pub fn to_function_metrics(function: &GoFunction) -> FunctionMetrics {
    FunctionMetrics {
        name: function.name.clone(),
        file: function.file.clone(),
        line: function.line,
        cyclomatic: function.cyclomatic,
        cognitive: function.cognitive,
        nesting: function.nesting,
        length: function.length,
        is_test: function.is_test,
        visibility: function.visibility.clone(),
        is_trait_method: false,
        in_test_module: function.is_test,
        entropy_score: None,
        is_pure: Some(is_pure(function.purity_level)),
        purity_confidence: Some(function.purity_confidence),
        purity_reason: purity_reason(function),
        call_dependencies: (!function.calls.is_empty()).then_some(function.calls.clone()),
        detected_patterns: (!function.purity_patterns.is_empty())
            .then_some(function.purity_patterns.clone()),
        upstream_callers: None,
        downstream_callees: None,
        mapping_pattern_result: None,
        adjusted_complexity: None,
        composition_metrics: None,
        language_specific: None,
        purity_level: Some(function.purity_level),
        error_swallowing_count: None,
        error_swallowing_patterns: None,
        entropy_analysis: None,
    }
}

fn purity_reason(function: &GoFunction) -> Option<String> {
    (!function.purity_patterns.is_empty()).then(|| function.purity_patterns.join(", "))
}

fn is_pure(level: crate::core::PurityLevel) -> bool {
    matches!(
        level,
        crate::core::PurityLevel::StrictlyPure | crate::core::PurityLevel::LocallyPure
    )
}