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

//! HTML SRP section: struct cohesion, module length, parameter count
//! sub-tables. The Structural variant is filtered out — it's rendered
//! by the cross-dim Structural section.

use super::html_escape;
use super::views::HtmlSrpView;
use crate::adapters::report::projections::srp::{
    split_srp_findings, SrpModuleRow, SrpParamRow, SrpStructRow,
};
use crate::domain::findings::SrpFinding;

/// Project SRP findings into the typed view via the shared splitter.
pub(super) fn build_srp_view(findings: &[SrpFinding]) -> HtmlSrpView {
    let buckets = split_srp_findings(findings);
    HtmlSrpView {
        struct_warnings: buckets.struct_warnings,
        module_warnings: buckets.module_warnings,
        param_warnings: buckets.param_warnings,
        structural_rows: buckets.structural_rows,
    }
}

pub(super) fn format_srp_section(view: &HtmlSrpView) -> String {
    let total = view.struct_warnings.len() + view.module_warnings.len() + view.param_warnings.len();
    let mut html = String::new();
    html.push_str(&format!(
        "<details>\n<summary>SRP \u{2014} {} Warning{}</summary>\n\
         <div class=\"detail-content\">\n",
        total,
        if total == 1 { "" } else { "s" },
    ));
    if total == 0 {
        html.push_str("<p class=\"empty-state\">No SRP warnings.</p>\n");
    }
    html.push_str(&format_struct_warnings(&view.struct_warnings));
    html.push_str(&format_module_warnings(&view.module_warnings));
    html.push_str(&format_param_warnings(&view.param_warnings));
    html.push_str("</div>\n</details>\n\n");
    html
}

fn html_table(title: &str, headers: &str, rows: Vec<String>) -> String {
    if rows.is_empty() {
        return String::new();
    }
    let mut html =
        format!("<h3>{title}</h3>\n<table>\n<thead><tr>{headers}</tr></thead>\n<tbody>\n");
    rows.iter().for_each(|r| html.push_str(r));
    html.push_str("</tbody></table>\n");
    html
}

fn format_struct_warnings(rows: &[SrpStructRow]) -> String {
    let rendered: Vec<String> = rows
        .iter()
        .map(|r| {
            format!(
                "<tr><td>{}</td><td>{}</td><td>{}</td>\
                 <td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>\n",
                html_escape(&r.struct_name),
                html_escape(&r.file),
                r.line,
                r.lcom4,
                r.field_count,
                r.method_count,
                r.fan_out,
            )
        })
        .collect();
    html_table(
        "Struct Warnings",
        "<th>Struct</th><th>File</th><th>Line</th>\
         <th>LCOM4</th><th>Fields</th><th>Methods</th><th>Fan-out</th>",
        rendered,
    )
}

fn format_module_warnings(rows: &[SrpModuleRow]) -> String {
    let rendered: Vec<String> = rows
        .iter()
        .map(|r| {
            let cluster_info = if r.independent_clusters > 0 {
                format!("{} clusters", r.independent_clusters)
            } else {
                String::from("\u{2014}")
            };
            format!(
                "<tr><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>\n",
                html_escape(&r.module),
                html_escape(&r.file),
                r.production_lines,
                cluster_info,
            )
        })
        .collect();
    html_table(
        "Module Warnings",
        "<th>Module</th><th>File</th><th>Production Lines</th><th>Clusters</th>",
        rendered,
    )
}

fn format_param_warnings(rows: &[SrpParamRow]) -> String {
    let rendered: Vec<String> = rows
        .iter()
        .map(|r| {
            format!(
                "<tr><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>\n",
                html_escape(&r.function_name),
                html_escape(&r.file),
                r.line,
                r.parameter_count,
            )
        })
        .collect();
    html_table(
        "Too-Many-Arguments Warnings",
        "<th>Function</th><th>File</th><th>Line</th><th>Params</th>",
        rendered,
    )
}