rustqual 1.0.0

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::adapters::analyzers::dry::wildcards::*;

fn parse(code: &str) -> Vec<(String, String, syn::File)> {
    let syntax = syn::parse_file(code).expect("parse failed");
    vec![("test.rs".to_string(), code.to_string(), syntax)]
}

#[test]
fn test_detects_simple_glob() {
    let parsed = parse("use crate::module::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 1);
    assert_eq!(warnings[0].module_path, "crate::module::*");
    assert_eq!(warnings[0].file, "test.rs");
}

#[test]
fn test_detects_nested_glob() {
    let parsed = parse("use crate::module::sub::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 1);
    assert_eq!(warnings[0].module_path, "crate::module::sub::*");
}

#[test]
fn test_no_warning_for_named_import() {
    let parsed = parse("use crate::module::Foo;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty());
}

#[test]
fn test_no_warning_for_group_import() {
    let parsed = parse("use crate::module::{Foo, Bar};");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty());
}

#[test]
fn test_glob_inside_group() {
    let parsed = parse("use crate::{module::*, other::Foo};");
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 1);
    assert_eq!(warnings[0].module_path, "crate::module::*");
}

#[test]
fn test_excludes_super_in_test() {
    let code = r#"
        #[cfg(test)]
        mod tests {
            use super::*;
        }
    "#;
    let parsed = parse(code);
    let warnings = detect_wildcard_imports(&parsed);
    assert!(
        warnings.is_empty(),
        "use super::* in #[cfg(test)] should be excluded"
    );
}

#[test]
fn test_super_glob_outside_test_flagged() {
    let code = "use super::*;";
    let parsed = parse(code);
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(
        warnings.len(),
        1,
        "use super::* outside test should be flagged"
    );
    assert_eq!(warnings[0].module_path, "super::*");
}

#[test]
fn test_excludes_prelude_glob() {
    let parsed = parse("use std::prelude::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty(), "prelude::* should be excluded");
}

#[test]
fn test_excludes_custom_prelude_glob() {
    let parsed = parse("use crate::prelude::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty(), "crate::prelude::* should be excluded");
}

#[test]
fn test_external_glob_detected() {
    let parsed = parse("use std::collections::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 1);
    assert_eq!(warnings[0].module_path, "std::collections::*");
}

#[test]
fn test_multiple_globs_in_file() {
    let code = "use crate::a::*;\nuse crate::b::*;\nuse crate::c::Foo;";
    let parsed = parse(code);
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 2);
}

#[test]
fn test_multiple_files() {
    let code1 = "use crate::module::*;";
    let code2 = "use crate::other::*;";
    let syntax1 = syn::parse_file(code1).unwrap();
    let syntax2 = syn::parse_file(code2).unwrap();
    let parsed = vec![
        ("a.rs".to_string(), code1.to_string(), syntax1),
        ("b.rs".to_string(), code2.to_string(), syntax2),
    ];
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 2);
    assert_eq!(warnings[0].file, "a.rs");
    assert_eq!(warnings[1].file, "b.rs");
}

#[test]
fn test_glob_line_number() {
    let code = "fn foo() {}\nuse crate::module::*;\nfn bar() {}";
    let parsed = parse(code);
    let warnings = detect_wildcard_imports(&parsed);
    assert_eq!(warnings.len(), 1);
    assert_eq!(warnings[0].line, 2);
}

#[test]
fn test_empty_file() {
    let parsed = parse("");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty());
}

#[test]
fn test_not_suppressed_by_default() {
    let parsed = parse("use crate::module::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(!warnings[0].suppressed);
}

#[test]
fn test_pub_use_reexport_excluded() {
    let parsed = parse("pub use crate::module::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(warnings.is_empty(), "pub use re-exports should be excluded");
}

#[test]
fn test_pub_crate_use_reexport_excluded() {
    let parsed = parse("pub(crate) use crate::module::*;");
    let warnings = detect_wildcard_imports(&parsed);
    assert!(
        warnings.is_empty(),
        "pub(crate) use re-exports should be excluded"
    );
}