rulewright 0.1.1

Executable engineering standards for Rust workspaces
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

use crate::{Example, FileCtx, Fix, Violation, infra::parse, violation};

const MIN_DECORATIVE_RUN: usize = 4;

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "plain separator",
        code: "// ----------------",
        pass: false,
    },
    Example {
        label: "framed banner",
        code: "// ==== parsing ====",
        pass: false,
    },
    Example {
        label: "mixed decorative separator",
        code: "// __~~__",
        pass: false,
    },
    Example {
        label: "ordinary comment",
        code: "// Parsing helpers live below.",
        pass: true,
    },
    Example {
        label: "short punctuation",
        code: "// --- note ---",
        pass: true,
    },
    Example {
        label: "comment-like string",
        code: "let banner = \"// --------\";",
        pass: true,
    },
];

crate::line_rule!(
    banner_comments,
    "Disallow decorative separator and framed banner comments.",
    "Structural code organization communicates sections more clearly than punctuation banners.",
    Low,
    fix_banner_comments,
);

fn check_banner_comments(ctx: &FileCtx<'_>) -> Vec<Violation> {
    ctx.lines
        .iter()
        .enumerate()
        .filter_map(|(index, line)| {
            let trimmed = line.trim();

            if !parse::is_comment(trimmed)
                || trimmed.starts_with("///")
                || trimmed.starts_with("//!")
            {
                return None;
            }

            let content = trimmed.strip_prefix("//")?.trim();

            is_banner(content).then(|| violation(ctx.rel, index + 1, "decorative banner comment"))
        })
        .collect()
}

fn is_banner(content: &str) -> bool {
    let chars: Vec<char> = content.chars().collect();

    if chars.is_empty() {
        return false;
    }

    let only_decorative = chars
        .iter()
        .all(|ch| ch.is_whitespace() || is_decorative(*ch));
    let leading = chars.iter().take_while(|ch| is_decorative(**ch)).count();
    let trailing = chars
        .iter()
        .rev()
        .take_while(|ch| is_decorative(**ch))
        .count();

    (only_decorative && longest_run(&chars) >= MIN_DECORATIVE_RUN)
        || (leading >= MIN_DECORATIVE_RUN && trailing >= MIN_DECORATIVE_RUN)
}

fn is_decorative(ch: char) -> bool {
    matches!(ch, '-' | '=' | '*' | '#' | '~' | '_')
}

fn longest_run(chars: &[char]) -> usize {
    let mut longest = 0;
    let mut current = 0;

    for ch in chars {
        if is_decorative(*ch) {
            current += 1;
            longest = longest.max(current);
        } else {
            current = 0;
        }
    }

    longest
}

#[expect(
    clippy::unnecessary_wraps,
    reason = "line-rule fixer callbacks uniformly return Option<Fix>"
)]
fn fix_banner_comments(_ctx: &FileCtx<'_>, violation: &Violation) -> Option<Fix> {
    Some(Fix::delete(violation.line, violation.line))
}

crate::rulewright_test!(check_banner_comments, {
    crate::example_tests!(EXAMPLES, check_banner_comments);
    crate::fix_tests!(line, check_banner_comments, fix_banner_comments);
});