rustqual 1.2.4

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

//! JSON `functions` section builder. Reads from typed `FunctionRecord`
//! state plus `IospFinding` violation locations.

use std::collections::BTreeMap;

use super::super::json_types::{JsonComplexity, JsonFunction, JsonHotspot, JsonMagicNumber};
use crate::domain::analysis_data::{FunctionClassification, FunctionRecord};
use crate::domain::findings::IospFinding;

pub(super) fn build_functions(
    functions: &[FunctionRecord],
    iosp_findings: &[IospFinding],
) -> Vec<JsonFunction> {
    functions
        .iter()
        .map(|f| {
            let (logic, calls) = violation_locations(f, iosp_findings);
            JsonFunction {
                name: f.name.clone(),
                file: f.file.clone(),
                line: f.line,
                parent_type: f.parent_type.clone(),
                classification: classification_str(f.classification).to_string(),
                severity: f.severity.clone(),
                suppressed: if f.suppressed { Some(true) } else { None },
                logic,
                calls,
                complexity: f.complexity.as_ref().map(|c| JsonComplexity {
                    logic_count: c.logic_count,
                    call_count: c.call_count,
                    max_nesting: c.max_nesting,
                    cognitive_complexity: c.cognitive_complexity,
                    cyclomatic_complexity: c.cyclomatic_complexity,
                    function_lines: c.function_lines,
                    unsafe_blocks: c.unsafe_blocks,
                    unwrap_count: c.unwrap_count,
                    expect_count: c.expect_count,
                    panic_count: c.panic_count,
                    todo_count: c.todo_count,
                    hotspots: c
                        .hotspots
                        .iter()
                        .map(|h| JsonHotspot {
                            line: h.line,
                            nesting_depth: h.nesting_depth,
                            construct: h.construct.clone(),
                        })
                        .collect(),
                    magic_numbers: c
                        .magic_numbers
                        .iter()
                        .map(|m| JsonMagicNumber {
                            line: m.line,
                            value: m.value.clone(),
                        })
                        .collect(),
                }),
                parameter_count: f.parameter_count,
                is_trait_impl: f.is_trait_impl,
                effort_score: f.effort_score,
            }
        })
        .collect()
}

fn classification_str(c: FunctionClassification) -> &'static str {
    match c {
        FunctionClassification::Integration => "integration",
        FunctionClassification::Operation => "operation",
        FunctionClassification::Trivial => "trivial",
        FunctionClassification::Violation => "violation",
    }
}

#[allow(clippy::type_complexity)]
fn violation_locations(
    f: &FunctionRecord,
    iosp_findings: &[IospFinding],
) -> (Vec<BTreeMap<String, String>>, Vec<BTreeMap<String, String>>) {
    let matching = iosp_findings
        .iter()
        .find(|finding| finding.common.file == f.file && finding.common.line == f.line);
    let Some(m) = matching else {
        return (vec![], vec![]);
    };
    let logic = m
        .logic_locations
        .iter()
        .map(|l| {
            let mut entry = BTreeMap::new();
            entry.insert("kind".into(), l.kind.clone());
            entry.insert("line".into(), l.line.to_string());
            entry
        })
        .collect();
    let calls = m
        .call_locations
        .iter()
        .map(|c| {
            let mut entry = BTreeMap::new();
            entry.insert("name".into(), c.name.clone());
            entry.insert("line".into(), c.line.to_string());
            entry
        })
        .collect();
    (logic, calls)
}