rustqual 1.2.2

Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture
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

//! Per-dim detail formatters: take a typed Finding's `details` enum
//! and produce a `(category, detail)` pair for the AI envelope.

use crate::config::Config;
use crate::domain::findings::{
    CouplingFinding, CouplingFindingDetails, DryFinding, DryFindingDetails, SrpFinding,
    SrpFindingDetails,
};

pub(super) fn dry_category_detail(f: &DryFinding) -> (&'static str, String) {
    match &f.details {
        DryFindingDetails::Duplicate { participants, .. } => {
            let partners: Vec<String> = participants
                .iter()
                .filter(|p| !(p.file == f.common.file && p.line == f.common.line))
                .map(|p| format!("{}:{}", p.file, p.line))
                .collect();
            let detail = if partners.is_empty() {
                "exact".to_string()
            } else {
                format!("exact with {}", partners.join(", "))
            };
            ("duplicate", detail)
        }
        DryFindingDetails::Fragment {
            participants,
            statement_count,
        } => {
            let partners: Vec<String> = participants
                .iter()
                .filter(|p| !(p.file == f.common.file && p.line == f.common.line))
                .map(|p| format!("{}:{}", p.file, p.line))
                .collect();
            let detail = if partners.is_empty() {
                format!("{statement_count} stmts")
            } else {
                format!("{statement_count} stmts also in {}", partners.join(", "))
            };
            ("fragment", detail)
        }
        DryFindingDetails::DeadCode {
            qualified_name,
            suggestion,
        } => {
            let s = suggestion.clone().unwrap_or_default();
            let detail = if s.is_empty() {
                qualified_name.clone()
            } else {
                format!("{qualified_name} ({s})")
            };
            ("dead_code", detail)
        }
        DryFindingDetails::Wildcard { module_path } => ("wildcard_import", module_path.clone()),
        DryFindingDetails::Boilerplate {
            pattern_id,
            suggestion,
            ..
        } => (
            "boilerplate",
            format!("{pattern_id}: {} — {suggestion}", f.common.message),
        ),
        DryFindingDetails::RepeatedMatch { enum_name, .. } => ("repeated_match", enum_name.clone()),
    }
}

pub(super) fn srp_category_detail(f: &SrpFinding, config: &Config) -> (&'static str, String) {
    match &f.details {
        SrpFindingDetails::StructCohesion {
            struct_name,
            lcom4,
            method_count,
            ..
        } => (
            "srp_struct",
            format!("{struct_name}: LCOM4={lcom4}, methods={method_count}"),
        ),
        SrpFindingDetails::ModuleLength {
            module,
            production_lines,
            independent_clusters,
            ..
        } => {
            let length_part = format!(
                "{production_lines} lines (max {})",
                config.srp.file_length_baseline
            );
            let cluster_part = if *independent_clusters > config.srp.max_independent_clusters {
                format!(
                    ", {independent_clusters} independent clusters (max {})",
                    config.srp.max_independent_clusters
                )
            } else {
                String::new()
            };
            (
                "srp_module",
                format!("{module}: {length_part}{cluster_part}"),
            )
        }
        SrpFindingDetails::ParameterCount {
            function_name,
            parameter_count,
        } => (
            "srp_params",
            format!(
                "{function_name}: {parameter_count} (max {})",
                config.srp.max_parameters
            ),
        ),
        SrpFindingDetails::Structural { code, detail, .. } => {
            ("structural", format!("{code}: {detail}"))
        }
    }
}

pub(super) fn coupling_category_detail(f: &CouplingFinding) -> (&'static str, String) {
    match &f.details {
        CouplingFindingDetails::Cycle { modules } => ("cycle", modules.join(" -> ")),
        CouplingFindingDetails::SdpViolation {
            from_module,
            to_module,
            from_instability,
            to_instability,
        } => (
            "sdp_violation",
            format!(
                "{from_module} -> {to_module} (stable I={from_instability:.2} imports unstable I={to_instability:.2})"
            ),
        ),
        CouplingFindingDetails::ThresholdExceeded {
            module_name,
            instability,
            ..
        } => ("coupling", format!("{module_name}: I={instability:.2}")),
        CouplingFindingDetails::Structural { code, detail, .. } => {
            ("structural", format!("{code}: {detail}"))
        }
    }
}