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 = "Severity::default_warn")]
70    pub unused_dev_dependencies: Severity,
71    #[serde(default = "Severity::default_warn")]
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::Warn,
101            unused_optional_dependencies: Severity::Warn,
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::Warn);
214        assert_eq!(rules.unused_optional_dependencies, Severity::Warn);
215        assert_eq!(rules.unused_enum_members, Severity::Error);
216        assert_eq!(rules.unused_class_members, Severity::Error);
217        assert_eq!(rules.unresolved_imports, Severity::Error);
218        assert_eq!(rules.unlisted_dependencies, Severity::Error);
219        assert_eq!(rules.duplicate_exports, Severity::Error);
220        assert_eq!(rules.type_only_dependencies, Severity::Warn);
221        assert_eq!(rules.test_only_dependencies, Severity::Warn);
222        assert_eq!(rules.circular_dependencies, Severity::Error);
223        assert_eq!(rules.boundary_violation, Severity::Error);
224    }
225
226    #[test]
227    fn rules_deserialize_kebab_case() {
228        let json_str = r#"{
229            "unused-files": "error",
230            "unused-exports": "warn",
231            "unused-types": "off"
232        }"#;
233        let rules: RulesConfig = serde_json::from_str(json_str).unwrap();
234        assert_eq!(rules.unused_files, Severity::Error);
235        assert_eq!(rules.unused_exports, Severity::Warn);
236        assert_eq!(rules.unused_types, Severity::Off);
237        // Unset fields default to error
238        assert_eq!(rules.unresolved_imports, Severity::Error);
239    }
240
241    #[test]
242    fn severity_from_str() {
243        assert_eq!("error".parse::<Severity>().unwrap(), Severity::Error);
244        assert_eq!("warn".parse::<Severity>().unwrap(), Severity::Warn);
245        assert_eq!("warning".parse::<Severity>().unwrap(), Severity::Warn);
246        assert_eq!("off".parse::<Severity>().unwrap(), Severity::Off);
247        assert_eq!("none".parse::<Severity>().unwrap(), Severity::Off);
248        assert!("invalid".parse::<Severity>().is_err());
249    }
250
251    #[test]
252    fn apply_partial_only_some_fields() {
253        let mut rules = RulesConfig::default();
254        let partial = PartialRulesConfig {
255            unused_files: Some(Severity::Warn),
256            unused_exports: Some(Severity::Off),
257            ..Default::default()
258        };
259        rules.apply_partial(&partial);
260        assert_eq!(rules.unused_files, Severity::Warn);
261        assert_eq!(rules.unused_exports, Severity::Off);
262        // Unset fields unchanged
263        assert_eq!(rules.unused_types, Severity::Error);
264        assert_eq!(rules.unresolved_imports, Severity::Error);
265    }
266
267    #[test]
268    fn severity_display() {
269        assert_eq!(Severity::Error.to_string(), "error");
270        assert_eq!(Severity::Warn.to_string(), "warn");
271        assert_eq!(Severity::Off.to_string(), "off");
272    }
273
274    #[test]
275    fn apply_partial_all_none_changes_nothing() {
276        let mut rules = RulesConfig::default();
277        let original = rules.clone();
278        let partial = PartialRulesConfig::default(); // all None
279        rules.apply_partial(&partial);
280        assert_eq!(rules.unused_files, original.unused_files);
281        assert_eq!(rules.unused_exports, original.unused_exports);
282        assert_eq!(
283            rules.type_only_dependencies,
284            original.type_only_dependencies
285        );
286    }
287
288    #[test]
289    fn apply_partial_all_fields_set() {
290        let mut rules = RulesConfig::default();
291        let partial = PartialRulesConfig {
292            unused_files: Some(Severity::Off),
293            unused_exports: Some(Severity::Off),
294            unused_types: Some(Severity::Off),
295            unused_dependencies: Some(Severity::Off),
296            unused_dev_dependencies: Some(Severity::Off),
297            unused_optional_dependencies: Some(Severity::Off),
298            unused_enum_members: Some(Severity::Off),
299            unused_class_members: Some(Severity::Off),
300            unresolved_imports: Some(Severity::Off),
301            unlisted_dependencies: Some(Severity::Off),
302            duplicate_exports: Some(Severity::Off),
303            type_only_dependencies: Some(Severity::Off),
304            test_only_dependencies: Some(Severity::Off),
305            circular_dependencies: Some(Severity::Off),
306            boundary_violation: Some(Severity::Off),
307        };
308        rules.apply_partial(&partial);
309        assert_eq!(rules.unused_files, Severity::Off);
310        assert_eq!(rules.circular_dependencies, Severity::Off);
311        assert_eq!(rules.type_only_dependencies, Severity::Off);
312        assert_eq!(rules.test_only_dependencies, Severity::Off);
313        assert_eq!(rules.boundary_violation, Severity::Off);
314    }
315
316    #[test]
317    fn rules_config_defaults_include_optional_deps() {
318        let rules = RulesConfig::default();
319        assert_eq!(rules.unused_optional_dependencies, Severity::Warn);
320    }
321
322    #[test]
323    fn severity_from_str_case_insensitive() {
324        assert_eq!("ERROR".parse::<Severity>().unwrap(), Severity::Error);
325        assert_eq!("Warn".parse::<Severity>().unwrap(), Severity::Warn);
326        assert_eq!("OFF".parse::<Severity>().unwrap(), Severity::Off);
327        assert_eq!("Warning".parse::<Severity>().unwrap(), Severity::Warn);
328        assert_eq!("NONE".parse::<Severity>().unwrap(), Severity::Off);
329    }
330
331    #[test]
332    fn severity_from_str_invalid_returns_error() {
333        let result = "critical".parse::<Severity>();
334        assert!(result.is_err());
335        let err = result.unwrap_err();
336        assert!(
337            err.contains("unknown severity"),
338            "Expected descriptive error, got: {err}"
339        );
340    }
341
342    // ── PartialRulesConfig deserialization ───────────────────────────
343
344    #[test]
345    fn partial_rules_empty_json() {
346        let partial: PartialRulesConfig = serde_json::from_str("{}").unwrap();
347        assert!(partial.unused_files.is_none());
348        assert!(partial.unused_exports.is_none());
349        assert!(partial.unused_types.is_none());
350        assert!(partial.unused_dependencies.is_none());
351        assert!(partial.circular_dependencies.is_none());
352        assert!(partial.boundary_violation.is_none());
353    }
354
355    #[test]
356    fn partial_rules_subset_json() {
357        let json = r#"{
358            "unused-files": "warn",
359            "circular-dependencies": "off"
360        }"#;
361        let partial: PartialRulesConfig = serde_json::from_str(json).unwrap();
362        assert_eq!(partial.unused_files, Some(Severity::Warn));
363        assert_eq!(partial.circular_dependencies, Some(Severity::Off));
364        assert!(partial.unused_exports.is_none());
365    }
366
367    #[test]
368    fn partial_rules_all_fields_json() {
369        let json = r#"{
370            "unused-files": "error",
371            "unused-exports": "warn",
372            "unused-types": "off",
373            "unused-dependencies": "error",
374            "unused-dev-dependencies": "warn",
375            "unused-optional-dependencies": "off",
376            "unused-enum-members": "error",
377            "unused-class-members": "warn",
378            "unresolved-imports": "off",
379            "unlisted-dependencies": "error",
380            "duplicate-exports": "warn",
381            "type-only-dependencies": "off",
382            "test-only-dependencies": "error",
383            "circular-dependencies": "warn",
384            "boundary-violation": "off"
385        }"#;
386        let partial: PartialRulesConfig = serde_json::from_str(json).unwrap();
387        assert_eq!(partial.unused_files, Some(Severity::Error));
388        assert_eq!(partial.unused_exports, Some(Severity::Warn));
389        assert_eq!(partial.unused_types, Some(Severity::Off));
390        assert_eq!(partial.unused_dependencies, Some(Severity::Error));
391        assert_eq!(partial.unused_dev_dependencies, Some(Severity::Warn));
392        assert_eq!(partial.unused_optional_dependencies, Some(Severity::Off));
393        assert_eq!(partial.unused_enum_members, Some(Severity::Error));
394        assert_eq!(partial.unused_class_members, Some(Severity::Warn));
395        assert_eq!(partial.unresolved_imports, Some(Severity::Off));
396        assert_eq!(partial.unlisted_dependencies, Some(Severity::Error));
397        assert_eq!(partial.duplicate_exports, Some(Severity::Warn));
398        assert_eq!(partial.type_only_dependencies, Some(Severity::Off));
399        assert_eq!(partial.test_only_dependencies, Some(Severity::Error));
400        assert_eq!(partial.circular_dependencies, Some(Severity::Warn));
401        assert_eq!(partial.boundary_violation, Some(Severity::Off));
402    }
403
404    // ── PartialRulesConfig serialization skip_serializing_if ────────
405
406    #[test]
407    fn partial_rules_none_fields_not_serialized() {
408        let partial = PartialRulesConfig::default();
409        let json = serde_json::to_string(&partial).unwrap();
410        assert_eq!(
411            json, "{}",
412            "all-None partial should serialize to empty object"
413        );
414    }
415
416    #[test]
417    fn partial_rules_some_fields_serialized() {
418        let partial = PartialRulesConfig {
419            unused_files: Some(Severity::Warn),
420            ..Default::default()
421        };
422        let json = serde_json::to_string(&partial).unwrap();
423        assert!(json.contains("unused-files"));
424        assert!(!json.contains("unused-exports"));
425    }
426
427    // ── Severity JSON deserialization ────────────────────────────────
428
429    #[test]
430    fn severity_json_deserialization() {
431        let error: Severity = serde_json::from_str(r#""error""#).unwrap();
432        assert_eq!(error, Severity::Error);
433
434        let warn: Severity = serde_json::from_str(r#""warn""#).unwrap();
435        assert_eq!(warn, Severity::Warn);
436
437        let off: Severity = serde_json::from_str(r#""off""#).unwrap();
438        assert_eq!(off, Severity::Off);
439    }
440
441    #[test]
442    fn severity_invalid_json_value_rejected() {
443        let result: Result<Severity, _> = serde_json::from_str(r#""critical""#);
444        assert!(result.is_err());
445    }
446
447    // ── Severity default ────────────────────────────────────────────
448
449    #[test]
450    fn severity_default_is_error() {
451        assert_eq!(Severity::default(), Severity::Error);
452    }
453
454    // ── RulesConfig JSON serialize roundtrip ─────────────────────────
455
456    #[test]
457    fn rules_config_json_roundtrip() {
458        let rules = RulesConfig {
459            unused_files: Severity::Warn,
460            unused_exports: Severity::Off,
461            type_only_dependencies: Severity::Error,
462            ..RulesConfig::default()
463        };
464        let json = serde_json::to_string(&rules).unwrap();
465        let restored: RulesConfig = serde_json::from_str(&json).unwrap();
466        assert_eq!(restored.unused_files, Severity::Warn);
467        assert_eq!(restored.unused_exports, Severity::Off);
468        assert_eq!(restored.type_only_dependencies, Severity::Error);
469        assert_eq!(restored.unused_dependencies, Severity::Error); // default
470    }
471
472    // ── apply_partial preserves type_only/test_only defaults ────────
473
474    #[test]
475    fn apply_partial_preserves_type_only_default() {
476        let mut rules = RulesConfig::default();
477        let partial = PartialRulesConfig {
478            unused_files: Some(Severity::Off),
479            ..Default::default()
480        };
481        rules.apply_partial(&partial);
482        // type_only_dependencies defaults to Warn, should be preserved
483        assert_eq!(rules.type_only_dependencies, Severity::Warn);
484        assert_eq!(rules.test_only_dependencies, Severity::Warn);
485    }
486}
fallow_config/config/rules.rs

fallow_config/config/
rules.rs
