oxicop 0.2.0

A blazing-fast Ruby linter and formatter, reimplemented in Rust
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

//! Cop registry for managing and filtering cops.

use std::collections::HashSet;

use crate::cop::Cop;
use crate::cops;

/// Registry that holds all cops and manages which ones are enabled.
pub struct CopRegistry {
    cops: Vec<Box<dyn Cop>>,
    disabled: HashSet<String>,
}

impl CopRegistry {
    /// Creates a new registry with all cops loaded.
    pub fn new() -> Self {
        Self {
            cops: cops::all_cops(),
            disabled: HashSet::new(),
        }
    }

    /// Disables a cop by name.
    pub fn disable(&mut self, name: &str) {
        self.disabled.insert(name.to_string());
    }

    /// Enables a previously disabled cop.
    pub fn enable(&mut self, name: &str) {
        self.disabled.remove(name);
    }

    /// Returns references to all currently enabled cops.
    pub fn enabled_cops(&self) -> Vec<&dyn Cop> {
        self.cops
            .iter()
            .filter(|cop| !self.disabled.contains(cop.name()))
            .map(|cop| cop.as_ref())
            .collect()
    }

    /// Returns all cop names (both enabled and disabled).
    pub fn cop_names(&self) -> Vec<&str> {
        self.cops.iter().map(|cop| cop.name()).collect()
    }

    /// Checks if a cop is enabled.
    pub fn is_enabled(&self, name: &str) -> bool {
        !self.disabled.contains(name)
    }

    /// Returns the total number of cops (enabled + disabled).
    pub fn total_count(&self) -> usize {
        self.cops.len()
    }

    /// Returns the number of enabled cops.
    pub fn enabled_count(&self) -> usize {
        self.cops.len() - self.disabled.len()
    }
}

impl Default for CopRegistry {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_registry_has_all_cops() {
        let registry = CopRegistry::new();
        assert!(registry.total_count() > 0);
        assert_eq!(registry.enabled_count(), registry.total_count());
    }

    #[test]
    fn test_disable_cop() {
        let mut registry = CopRegistry::new();
        let initial_count = registry.enabled_count();
        
        registry.disable("Layout/TrailingWhitespace");
        
        assert_eq!(registry.enabled_count(), initial_count - 1);
        assert!(!registry.is_enabled("Layout/TrailingWhitespace"));
    }

    #[test]
    fn test_enable_cop() {
        let mut registry = CopRegistry::new();
        
        registry.disable("Layout/TrailingWhitespace");
        assert!(!registry.is_enabled("Layout/TrailingWhitespace"));
        
        registry.enable("Layout/TrailingWhitespace");
        assert!(registry.is_enabled("Layout/TrailingWhitespace"));
    }

    #[test]
    fn test_enabled_cops_filter() {
        let mut registry = CopRegistry::new();
        let total = registry.total_count();
        
        registry.disable("Layout/TrailingWhitespace");
        registry.disable("Style/StringLiterals");
        
        let enabled = registry.enabled_cops();
        assert_eq!(enabled.len(), total - 2);
        
        for cop in enabled {
            assert!(cop.name() != "Layout/TrailingWhitespace");
            assert!(cop.name() != "Style/StringLiterals");
        }
    }

    #[test]
    fn test_cop_names_returns_all() {
        let registry = CopRegistry::new();
        let names = registry.cop_names();
        
        assert_eq!(names.len(), registry.total_count());
        assert!(names.contains(&"Layout/TrailingWhitespace"));
        assert!(names.contains(&"Style/StringLiterals"));
    }

    #[test]
    fn test_disable_nonexistent_cop() {
        let mut registry = CopRegistry::new();
        let initial_count = registry.enabled_count();

        registry.disable("NonExistent/Cop");

        // Note: Due to the implementation, disabling a non-existent cop still adds it to
        // the disabled set, which decreases the enabled_count even though no actual cop
        // was disabled. This is arguably a quirk but reflects current behavior.
        assert_eq!(registry.enabled_count(), initial_count - 1);
    }
}