rrubocop 0.7.1

Fast RuboCop-compatible Ruby linter in Rust (tree-sitter). No Ruby for linting; ERB configs need ruby.
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

use std::collections::HashSet;

use crate::cop::{Cop, CopConfig};
use crate::diagnostic::{Diagnostic, Severity};
use crate::parse::codemap::CodeMap;
use crate::parse::source::SourceFile;

/// Lint/RedundantCopEnableDirective — enable without matching disable.
pub struct RedundantCopEnableDirective;

fn directive_names(rest: &str) -> Vec<String> {
    let cops = rest
        .trim()
        .trim_start_matches(':')
        .trim()
        .split("--")
        .next()
        .unwrap_or("");
    let names: Vec<String> = cops
        .split(',')
        .map(|c| c.trim().to_string())
        .filter(|c| !c.is_empty())
        .collect();
    if names.is_empty() {
        vec!["all".into()]
    } else {
        names
    }
}

fn config_disabled(config: &CopConfig) -> HashSet<String> {
    match config.options.get("ConfigDisabledCops") {
        Some(serde_yml::Value::Sequence(items)) => items
            .iter()
            .filter_map(|v| v.as_str().map(str::to_string))
            .collect(),
        _ => HashSet::new(),
    }
}

fn check_enable(
    cop: &RedundantCopEnableDirective,
    source: &SourceFile,
    disabled: &mut HashSet<String>,
    line: &str,
    line_no: usize,
    diagnostics: &mut Vec<Diagnostic>,
) {
    let Some(rest) = line.split("# rubocop:enable").nth(1) else {
        return;
    };
    if !line.trim_start().starts_with('#') {
        return;
    }
    for name in directive_names(rest) {
        if disabled.remove(&name) || disabled.contains("all") {
            continue;
        }
        diagnostics.push(cop.diagnostic(
            source,
            line_no,
            0,
            format!("Unnecessary enabling of {name}."),
        ));
    }
}

impl Cop for RedundantCopEnableDirective {
    fn name(&self) -> &'static str {
        "Lint/RedundantCopEnableDirective"
    }

    fn default_severity(&self) -> Severity {
        Severity::Warning
    }

    fn uses_source_phase(&self) -> bool {
        true
    }

    fn check_source(
        &self,
        source: &SourceFile,
        _tree: &tree_sitter::Tree,
        _code_map: &CodeMap,
        config: &CopConfig,
        diagnostics: &mut Vec<Diagnostic>,
        _corrections: Option<&mut Vec<crate::correction::Correction>>,
    ) {
        // RuboCop seeds disable counts with cops disabled in config.
        let mut disabled = config_disabled(config);
        for (i, line) in source.lines().enumerate() {
            let s = String::from_utf8_lossy(line);
            if let Some(rest) = s.split("# rubocop:disable").nth(1) {
                for name in directive_names(rest) {
                    disabled.insert(name);
                }
            }
            check_enable(self, source, &mut disabled, &s, i + 1, diagnostics);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    crate::cop_fixture_tests!(
        RedundantCopEnableDirective,
        "cops/lint/redundant_cop_enable_directive"
    );

    #[test]
    fn config_disabled_enable_ok() {
        let mut config = CopConfig::default();
        config.options.insert(
            "ConfigDisabledCops".into(),
            serde_yml::Value::Sequence(vec![serde_yml::Value::String(
                "Layout/LineLength".into(),
            )]),
        );
        crate::testutil::assert_cop_no_offenses_full_with_config(
            &RedundantCopEnableDirective,
            b"x = 1\n# rubocop:enable Layout/LineLength\n",
            config,
        );
    }
}