rustqual 1.2.3

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

use crate::app::analyze_codebase::analyze_codebase;
use crate::config::Config;
use crate::domain::{Dimension, Finding, Severity};
use crate::ports::{AnalysisContext, DimensionAnalyzer, ParsedFile};

struct StubAnalyzer {
    name: &'static str,
    findings: Vec<Finding>,
}

impl DimensionAnalyzer for StubAnalyzer {
    fn dimension_name(&self) -> &'static str {
        self.name
    }
    fn analyze(&self, _ctx: &AnalysisContext<'_>) -> Vec<Finding> {
        self.findings.clone()
    }
}

fn empty_ctx() -> (Vec<ParsedFile>, Config) {
    (Vec::new(), Config::default())
}

fn stub_finding(rule: &str) -> Finding {
    Finding {
        rule_id: rule.to_string(),
        dimension: Dimension::Architecture,
        severity: Severity::Medium,
        ..Finding::default()
    }
}

#[test]
fn empty_analyzer_list_yields_empty() {
    let (files, cfg) = empty_ctx();
    let ctx = AnalysisContext {
        files: &files,
        config: &cfg,
    };
    let out = analyze_codebase(&[], &ctx);
    assert!(out.is_empty());
}

#[test]
fn concatenates_findings_from_each_analyzer() {
    let (files, cfg) = empty_ctx();
    let ctx = AnalysisContext {
        files: &files,
        config: &cfg,
    };
    let a: Box<dyn DimensionAnalyzer> = Box::new(StubAnalyzer {
        name: "a",
        findings: vec![stub_finding("a/x"), stub_finding("a/y")],
    });
    let b: Box<dyn DimensionAnalyzer> = Box::new(StubAnalyzer {
        name: "b",
        findings: vec![stub_finding("b/z")],
    });
    let analyzers: Vec<Box<dyn DimensionAnalyzer>> = vec![a, b];
    let out = analyze_codebase(&analyzers, &ctx);
    let ids: Vec<&str> = out.iter().map(|f| f.rule_id.as_str()).collect();
    assert_eq!(ids, vec!["a/x", "a/y", "b/z"]);
}

#[test]
fn preserves_analyzer_order() {
    let (files, cfg) = empty_ctx();
    let ctx = AnalysisContext {
        files: &files,
        config: &cfg,
    };
    let first: Box<dyn DimensionAnalyzer> = Box::new(StubAnalyzer {
        name: "first",
        findings: vec![stub_finding("first")],
    });
    let second: Box<dyn DimensionAnalyzer> = Box::new(StubAnalyzer {
        name: "second",
        findings: vec![stub_finding("second")],
    });
    let analyzers: Vec<Box<dyn DimensionAnalyzer>> = vec![first, second];
    let out = analyze_codebase(&analyzers, &ctx);
    assert_eq!(out[0].rule_id, "first");
    assert_eq!(out[1].rule_id, "second");
}