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

//! IOSP-dimension projection: `Classification::Violation` → typed
//! `Vec<IospFinding>` with logic + call locations.

use crate::adapters::analyzers::iosp::{
    CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence,
};
use crate::domain::findings::{CallLocation, IospFinding, LogicLocation};
use crate::domain::{Dimension, Finding, Severity};

const DIM: Dimension = Dimension::Iosp;
const RULE_ID: &str = "iosp/violation";

/// Project IOSP analyzer output into typed IospFinding entries.
///
/// Only `Classification::Violation` produces findings. Suppressed functions
/// are still included with `common.suppressed = true` so reporters can
/// surface the suppression ratio.
pub(crate) fn project_iosp(results: &[FunctionAnalysis]) -> Vec<IospFinding> {
    results
        .iter()
        .filter_map(|f| match &f.classification {
            Classification::Violation {
                logic_locations,
                call_locations,
                ..
            } => Some(build(f, logic_locations, call_locations)),
            _ => None,
        })
        .collect()
}

fn build(
    f: &FunctionAnalysis,
    logic_locations: &[LogicOccurrence],
    call_locations: &[CallOccurrence],
) -> IospFinding {
    IospFinding {
        common: Finding {
            file: f.file.clone(),
            line: f.line,
            column: 0,
            dimension: DIM,
            rule_id: RULE_ID.into(),
            message: format!(
                "IOSP violation in {}: logic + calls mixed",
                f.qualified_name
            ),
            severity: f.severity.clone().unwrap_or(Severity::Medium),
            suppressed: f.suppressed,
        },
        logic_locations: logic_locations
            .iter()
            .map(|l| LogicLocation {
                kind: l.kind.clone(),
                line: l.line,
            })
            .collect(),
        call_locations: call_locations
            .iter()
            .map(|c| CallLocation {
                name: c.name.clone(),
                line: c.line,
            })
            .collect(),
        effort_score: f.effort_score,
    }
}