fallow_config/config/
rules.rs

1use schemars::JsonSchema;
2use serde::{Deserialize, Serialize};
3
4/// Severity level for rules.
5///
6/// Controls whether an issue type causes CI failure (`error`), is reported
7/// without failing (`warn`), or is suppressed entirely (`off`).
8#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, JsonSchema)]
9#[serde(rename_all = "lowercase")]
10pub enum Severity {
11    /// Report and fail CI (non-zero exit code).
12    #[default]
13    Error,
14    /// Report but don't fail CI.
15    Warn,
16    /// Don't detect or report.
17    Off,
18}
19
20impl Severity {
21    /// Default value for fields that should default to `Warn` instead of `Error`.
22    const fn default_warn() -> Self {
23        Self::Warn
24    }
25}
26
27impl std::fmt::Display for Severity {
28    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29        match self {
30            Self::Error => write!(f, "error"),
31            Self::Warn => write!(f, "warn"),
32            Self::Off => write!(f, "off"),
33        }
34    }
35}
36
37impl std::str::FromStr for Severity {
38    type Err = String;
39
40    fn from_str(s: &str) -> Result<Self, Self::Err> {
41        match s.to_lowercase().as_str() {
42            "error" => Ok(Self::Error),
43            "warn" | "warning" => Ok(Self::Warn),
44            "off" | "none" => Ok(Self::Off),
45            other => Err(format!(
46                "unknown severity: '{other}' (expected error, warn, or off)"
47            )),
48        }
49    }
50}
51
52/// Per-issue-type severity configuration.
53///
54/// Controls which issue types cause CI failure, are reported as warnings,
55/// or are suppressed entirely. All fields default to `Severity::Error`.
56///
57/// Rule names use kebab-case in config files (e.g., `"unused-files": "error"`).
58#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
59#[serde(rename_all = "kebab-case")]
60pub struct RulesConfig {
61    #[serde(default)]
62    pub unused_files: Severity,
63    #[serde(default)]
64    pub unused_exports: Severity,
65    #[serde(default)]
66    pub unused_types: Severity,
67    #[serde(default)]
68    pub unused_dependencies: Severity,
69    #[serde(default)]
70    pub unused_dev_dependencies: Severity,
71    #[serde(default)]
72    pub unused_optional_dependencies: Severity,
73    #[serde(default)]
74    pub unused_enum_members: Severity,
75    #[serde(default)]
76    pub unused_class_members: Severity,
77    #[serde(default)]
78    pub unresolved_imports: Severity,
79    #[serde(default)]
80    pub unlisted_dependencies: Severity,
81    #[serde(default)]
82    pub duplicate_exports: Severity,
83    #[serde(default = "Severity::default_warn")]
84    pub type_only_dependencies: Severity,
85    #[serde(default = "Severity::default_warn")]
86    pub test_only_dependencies: Severity,
87    #[serde(default)]
88    pub circular_dependencies: Severity,
89    #[serde(default)]
90    pub boundary_violation: Severity,
91}
92
93impl Default for RulesConfig {
94    fn default() -> Self {
95        Self {
96            unused_files: Severity::Error,
97            unused_exports: Severity::Error,
98            unused_types: Severity::Error,
99            unused_dependencies: Severity::Error,
100            unused_dev_dependencies: Severity::Error,
101            unused_optional_dependencies: Severity::Error,
102            unused_enum_members: Severity::Error,
103            unused_class_members: Severity::Error,
104            unresolved_imports: Severity::Error,
105            unlisted_dependencies: Severity::Error,
106            duplicate_exports: Severity::Error,
107            type_only_dependencies: Severity::Warn,
108            test_only_dependencies: Severity::Warn,
109            circular_dependencies: Severity::Error,
110            boundary_violation: Severity::Error,
111        }
112    }
113}
114
115impl RulesConfig {
116    /// Apply a partial rules config on top. Only `Some` fields override.
117    pub const fn apply_partial(&mut self, partial: &PartialRulesConfig) {
118        if let Some(s) = partial.unused_files {
119            self.unused_files = s;
120        }
121        if let Some(s) = partial.unused_exports {
122            self.unused_exports = s;
123        }
124        if let Some(s) = partial.unused_types {
125            self.unused_types = s;
126        }
127        if let Some(s) = partial.unused_dependencies {
128            self.unused_dependencies = s;
129        }
130        if let Some(s) = partial.unused_dev_dependencies {
131            self.unused_dev_dependencies = s;
132        }
133        if let Some(s) = partial.unused_optional_dependencies {
134            self.unused_optional_dependencies = s;
135        }
136        if let Some(s) = partial.unused_enum_members {
137            self.unused_enum_members = s;
138        }
139        if let Some(s) = partial.unused_class_members {
140            self.unused_class_members = s;
141        }
142        if let Some(s) = partial.unresolved_imports {
143            self.unresolved_imports = s;
144        }
145        if let Some(s) = partial.unlisted_dependencies {
146            self.unlisted_dependencies = s;
147        }
148        if let Some(s) = partial.duplicate_exports {
149            self.duplicate_exports = s;
150        }
151        if let Some(s) = partial.type_only_dependencies {
152            self.type_only_dependencies = s;
153        }
154        if let Some(s) = partial.test_only_dependencies {
155            self.test_only_dependencies = s;
156        }
157        if let Some(s) = partial.circular_dependencies {
158            self.circular_dependencies = s;
159        }
160        if let Some(s) = partial.boundary_violation {
161            self.boundary_violation = s;
162        }
163    }
164}
165
166/// Partial per-issue-type severity for overrides. All fields optional.
167#[derive(Debug, Default, Clone, Deserialize, Serialize, JsonSchema)]
168#[serde(rename_all = "kebab-case")]
169pub struct PartialRulesConfig {
170    #[serde(default, skip_serializing_if = "Option::is_none")]
171    pub unused_files: Option<Severity>,
172    #[serde(default, skip_serializing_if = "Option::is_none")]
173    pub unused_exports: Option<Severity>,
174    #[serde(default, skip_serializing_if = "Option::is_none")]
175    pub unused_types: Option<Severity>,
176    #[serde(default, skip_serializing_if = "Option::is_none")]
177    pub unused_dependencies: Option<Severity>,
178    #[serde(default, skip_serializing_if = "Option::is_none")]
179    pub unused_dev_dependencies: Option<Severity>,
180    #[serde(default, skip_serializing_if = "Option::is_none")]
181    pub unused_optional_dependencies: Option<Severity>,
182    #[serde(default, skip_serializing_if = "Option::is_none")]
183    pub unused_enum_members: Option<Severity>,
184    #[serde(default, skip_serializing_if = "Option::is_none")]
185    pub unused_class_members: Option<Severity>,
186    #[serde(default, skip_serializing_if = "Option::is_none")]
187    pub unresolved_imports: Option<Severity>,
188    #[serde(default, skip_serializing_if = "Option::is_none")]
189    pub unlisted_dependencies: Option<Severity>,
190    #[serde(default, skip_serializing_if = "Option::is_none")]
191    pub duplicate_exports: Option<Severity>,
192    #[serde(default, skip_serializing_if = "Option::is_none")]
193    pub type_only_dependencies: Option<Severity>,
194    #[serde(default, skip_serializing_if = "Option::is_none")]
195    pub test_only_dependencies: Option<Severity>,
196    #[serde(default, skip_serializing_if = "Option::is_none")]
197    pub circular_dependencies: Option<Severity>,
198    #[serde(default, skip_serializing_if = "Option::is_none")]
199    pub boundary_violation: Option<Severity>,
200}
201
202#[cfg(test)]
203mod tests {
204    use super::*;
205
206    #[test]
207    fn rules_default_all_error_except_type_only() {
208        let rules = RulesConfig::default();
209        assert_eq!(rules.unused_files, Severity::Error);
210        assert_eq!(rules.unused_exports, Severity::Error);
211        assert_eq!(rules.unused_types, Severity::Error);
212        assert_eq!(rules.unused_dependencies, Severity::Error);
213        assert_eq!(rules.unused_dev_dependencies, Severity::Error);
214        assert_eq!(rules.unused_enum_members, Severity::Error);
215        assert_eq!(rules.unused_class_members, Severity::Error);
216        assert_eq!(rules.unresolved_imports, Severity::Error);
217        assert_eq!(rules.unlisted_dependencies, Severity::Error);
218        assert_eq!(rules.duplicate_exports, Severity::Error);
219        assert_eq!(rules.type_only_dependencies, Severity::Warn);
220        assert_eq!(rules.test_only_dependencies, Severity::Warn);
221        assert_eq!(rules.circular_dependencies, Severity::Error);
222        assert_eq!(rules.boundary_violation, Severity::Error);
223    }
224
225    #[test]
226    fn rules_deserialize_kebab_case() {
227        let json_str = r#"{
228            "unused-files": "error",
229            "unused-exports": "warn",
230            "unused-types": "off"
231        }"#;
232        let rules: RulesConfig = serde_json::from_str(json_str).unwrap();
233        assert_eq!(rules.unused_files, Severity::Error);
234        assert_eq!(rules.unused_exports, Severity::Warn);
235        assert_eq!(rules.unused_types, Severity::Off);
236        // Unset fields default to error
237        assert_eq!(rules.unresolved_imports, Severity::Error);
238    }
239
240    #[test]
241    fn severity_from_str() {
242        assert_eq!("error".parse::<Severity>().unwrap(), Severity::Error);
243        assert_eq!("warn".parse::<Severity>().unwrap(), Severity::Warn);
244        assert_eq!("warning".parse::<Severity>().unwrap(), Severity::Warn);
245        assert_eq!("off".parse::<Severity>().unwrap(), Severity::Off);
246        assert_eq!("none".parse::<Severity>().unwrap(), Severity::Off);
247        assert!("invalid".parse::<Severity>().is_err());
248    }
249
250    #[test]
251    fn apply_partial_only_some_fields() {
252        let mut rules = RulesConfig::default();
253        let partial = PartialRulesConfig {
254            unused_files: Some(Severity::Warn),
255            unused_exports: Some(Severity::Off),
256            ..Default::default()
257        };
258        rules.apply_partial(&partial);
259        assert_eq!(rules.unused_files, Severity::Warn);
260        assert_eq!(rules.unused_exports, Severity::Off);
261        // Unset fields unchanged
262        assert_eq!(rules.unused_types, Severity::Error);
263        assert_eq!(rules.unresolved_imports, Severity::Error);
264    }
265
266    #[test]
267    fn severity_display() {
268        assert_eq!(Severity::Error.to_string(), "error");
269        assert_eq!(Severity::Warn.to_string(), "warn");
270        assert_eq!(Severity::Off.to_string(), "off");
271    }
272
273    #[test]
274    fn apply_partial_all_none_changes_nothing() {
275        let mut rules = RulesConfig::default();
276        let original = rules.clone();
277        let partial = PartialRulesConfig::default(); // all None
278        rules.apply_partial(&partial);
279        assert_eq!(rules.unused_files, original.unused_files);
280        assert_eq!(rules.unused_exports, original.unused_exports);
281        assert_eq!(
282            rules.type_only_dependencies,
283            original.type_only_dependencies
284        );
285    }
286
287    #[test]
288    fn apply_partial_all_fields_set() {
289        let mut rules = RulesConfig::default();
290        let partial = PartialRulesConfig {
291            unused_files: Some(Severity::Off),
292            unused_exports: Some(Severity::Off),
293            unused_types: Some(Severity::Off),
294            unused_dependencies: Some(Severity::Off),
295            unused_dev_dependencies: Some(Severity::Off),
296            unused_optional_dependencies: Some(Severity::Off),
297            unused_enum_members: Some(Severity::Off),
298            unused_class_members: Some(Severity::Off),
299            unresolved_imports: Some(Severity::Off),
300            unlisted_dependencies: Some(Severity::Off),
301            duplicate_exports: Some(Severity::Off),
302            type_only_dependencies: Some(Severity::Off),
303            test_only_dependencies: Some(Severity::Off),
304            circular_dependencies: Some(Severity::Off),
305            boundary_violation: Some(Severity::Off),
306        };
307        rules.apply_partial(&partial);
308        assert_eq!(rules.unused_files, Severity::Off);
309        assert_eq!(rules.circular_dependencies, Severity::Off);
310        assert_eq!(rules.type_only_dependencies, Severity::Off);
311        assert_eq!(rules.test_only_dependencies, Severity::Off);
312        assert_eq!(rules.boundary_violation, Severity::Off);
313    }
314
315    #[test]
316    fn rules_config_defaults_include_optional_deps() {
317        let rules = RulesConfig::default();
318        assert_eq!(rules.unused_optional_dependencies, Severity::Error);
319    }
320
321    #[test]
322    fn severity_from_str_case_insensitive() {
323        assert_eq!("ERROR".parse::<Severity>().unwrap(), Severity::Error);
324        assert_eq!("Warn".parse::<Severity>().unwrap(), Severity::Warn);
325        assert_eq!("OFF".parse::<Severity>().unwrap(), Severity::Off);
326        assert_eq!("Warning".parse::<Severity>().unwrap(), Severity::Warn);
327        assert_eq!("NONE".parse::<Severity>().unwrap(), Severity::Off);
328    }
329
330    #[test]
331    fn severity_from_str_invalid_returns_error() {
332        let result = "critical".parse::<Severity>();
333        assert!(result.is_err());
334        let err = result.unwrap_err();
335        assert!(
336            err.contains("unknown severity"),
337            "Expected descriptive error, got: {err}"
338        );
339    }
340}
fallow_config/config/rules.rs

fallow_config/config/
rules.rs
