rustqual 0.5.1

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

use crate::findings::Suppression;

/// Trait for DRY finding groups that can be suppressed.
pub(crate) trait DrySuppressible {
    fn set_suppressed(&mut self, val: bool);
    fn entry_locations(&self) -> Vec<(&str, usize)>;
}

impl DrySuppressible for crate::dry::functions::DuplicateGroup {
    fn set_suppressed(&mut self, val: bool) {
        self.suppressed = val;
    }
    fn entry_locations(&self) -> Vec<(&str, usize)> {
        self.entries
            .iter()
            .map(|e| (e.file.as_str(), e.line))
            .collect()
    }
}

impl DrySuppressible for crate::dry::match_patterns::RepeatedMatchGroup {
    fn set_suppressed(&mut self, val: bool) {
        self.suppressed = val;
    }
    fn entry_locations(&self) -> Vec<(&str, usize)> {
        self.entries
            .iter()
            .map(|e| (e.file.as_str(), e.line))
            .collect()
    }
}

impl DrySuppressible for crate::dry::fragments::FragmentGroup {
    fn set_suppressed(&mut self, val: bool) {
        self.suppressed = val;
    }
    fn entry_locations(&self) -> Vec<(&str, usize)> {
        self.entries
            .iter()
            .map(|e| (e.file.as_str(), e.start_line))
            .collect()
    }
}

impl DrySuppressible for crate::dry::boilerplate::BoilerplateFind {
    fn set_suppressed(&mut self, val: bool) {
        self.suppressed = val;
    }
    fn entry_locations(&self) -> Vec<(&str, usize)> {
        vec![(self.file.as_str(), self.line)]
    }
}

/// Mark DRY finding groups as suppressed when any entry has `// qual:allow(dry)`.
/// Operation: iterates groups checking entries against suppression lines.
pub(crate) fn mark_dry_suppressions<T: DrySuppressible>(
    groups: &mut [T],
    suppression_lines: &std::collections::HashMap<String, Vec<Suppression>>,
) {
    let dry_dim = crate::findings::Dimension::Dry;
    groups.iter_mut().for_each(|g| {
        let suppressed = g.entry_locations().iter().any(|(file, line)| {
            suppression_lines
                .get(*file)
                .map(|sups| {
                    sups.iter().any(|sup| {
                        crate::findings::is_within_window(sup.line, *line) && sup.covers(dry_dim)
                    })
                })
                .unwrap_or(false)
        });
        g.set_suppressed(suppressed);
    });
}

/// Mark duplicate groups as suppressed when members are `// qual:inverse(fn)` pairs.
/// Operation: iterates groups checking entries against inverse annotation lines.
pub(super) fn mark_inverse_suppressions(
    groups: &mut [crate::dry::functions::DuplicateGroup],
    inverse_lines: &std::collections::HashMap<String, Vec<(usize, String)>>,
) {
    let window = crate::findings::ANNOTATION_WINDOW;
    groups.iter_mut().filter(|g| !g.suppressed).for_each(|g| {
        g.suppressed = g.entries.iter().any(|entry| {
            inverse_lines
                .get(&entry.file)
                .map(|inv| {
                    inv.iter().any(|(line, target)| {
                        let in_window = *line <= entry.line && entry.line - line <= window;
                        in_window
                            && g.entries.iter().any(|other| {
                                other.name == *target || other.qualified_name == *target
                            })
                    })
                })
                .unwrap_or(false)
        });
    });
}