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)]
86    pub circular_dependencies: Severity,
87}
88
89impl Default for RulesConfig {
90    fn default() -> Self {
91        Self {
92            unused_files: Severity::Error,
93            unused_exports: Severity::Error,
94            unused_types: Severity::Error,
95            unused_dependencies: Severity::Error,
96            unused_dev_dependencies: Severity::Error,
97            unused_optional_dependencies: Severity::Error,
98            unused_enum_members: Severity::Error,
99            unused_class_members: Severity::Error,
100            unresolved_imports: Severity::Error,
101            unlisted_dependencies: Severity::Error,
102            duplicate_exports: Severity::Error,
103            type_only_dependencies: Severity::Warn,
104            circular_dependencies: Severity::Error,
105        }
106    }
107}
108
109impl RulesConfig {
110    /// Apply a partial rules config on top. Only `Some` fields override.
111    pub const fn apply_partial(&mut self, partial: &PartialRulesConfig) {
112        if let Some(s) = partial.unused_files {
113            self.unused_files = s;
114        }
115        if let Some(s) = partial.unused_exports {
116            self.unused_exports = s;
117        }
118        if let Some(s) = partial.unused_types {
119            self.unused_types = s;
120        }
121        if let Some(s) = partial.unused_dependencies {
122            self.unused_dependencies = s;
123        }
124        if let Some(s) = partial.unused_dev_dependencies {
125            self.unused_dev_dependencies = s;
126        }
127        if let Some(s) = partial.unused_optional_dependencies {
128            self.unused_optional_dependencies = s;
129        }
130        if let Some(s) = partial.unused_enum_members {
131            self.unused_enum_members = s;
132        }
133        if let Some(s) = partial.unused_class_members {
134            self.unused_class_members = s;
135        }
136        if let Some(s) = partial.unresolved_imports {
137            self.unresolved_imports = s;
138        }
139        if let Some(s) = partial.unlisted_dependencies {
140            self.unlisted_dependencies = s;
141        }
142        if let Some(s) = partial.duplicate_exports {
143            self.duplicate_exports = s;
144        }
145        if let Some(s) = partial.type_only_dependencies {
146            self.type_only_dependencies = s;
147        }
148        if let Some(s) = partial.circular_dependencies {
149            self.circular_dependencies = s;
150        }
151    }
152}
153
154/// Partial per-issue-type severity for overrides. All fields optional.
155#[derive(Debug, Default, Clone, Deserialize, Serialize, JsonSchema)]
156#[serde(rename_all = "kebab-case")]
157pub struct PartialRulesConfig {
158    #[serde(default, skip_serializing_if = "Option::is_none")]
159    pub unused_files: Option<Severity>,
160    #[serde(default, skip_serializing_if = "Option::is_none")]
161    pub unused_exports: Option<Severity>,
162    #[serde(default, skip_serializing_if = "Option::is_none")]
163    pub unused_types: Option<Severity>,
164    #[serde(default, skip_serializing_if = "Option::is_none")]
165    pub unused_dependencies: Option<Severity>,
166    #[serde(default, skip_serializing_if = "Option::is_none")]
167    pub unused_dev_dependencies: Option<Severity>,
168    #[serde(default, skip_serializing_if = "Option::is_none")]
169    pub unused_optional_dependencies: Option<Severity>,
170    #[serde(default, skip_serializing_if = "Option::is_none")]
171    pub unused_enum_members: Option<Severity>,
172    #[serde(default, skip_serializing_if = "Option::is_none")]
173    pub unused_class_members: Option<Severity>,
174    #[serde(default, skip_serializing_if = "Option::is_none")]
175    pub unresolved_imports: Option<Severity>,
176    #[serde(default, skip_serializing_if = "Option::is_none")]
177    pub unlisted_dependencies: Option<Severity>,
178    #[serde(default, skip_serializing_if = "Option::is_none")]
179    pub duplicate_exports: Option<Severity>,
180    #[serde(default, skip_serializing_if = "Option::is_none")]
181    pub type_only_dependencies: Option<Severity>,
182    #[serde(default, skip_serializing_if = "Option::is_none")]
183    pub circular_dependencies: Option<Severity>,
184}
185
186#[cfg(test)]
187mod tests {
188    use super::*;
189
190    #[test]
191    fn rules_default_all_error_except_type_only() {
192        let rules = RulesConfig::default();
193        assert_eq!(rules.unused_files, Severity::Error);
194        assert_eq!(rules.unused_exports, Severity::Error);
195        assert_eq!(rules.unused_types, Severity::Error);
196        assert_eq!(rules.unused_dependencies, Severity::Error);
197        assert_eq!(rules.unused_dev_dependencies, Severity::Error);
198        assert_eq!(rules.unused_enum_members, Severity::Error);
199        assert_eq!(rules.unused_class_members, Severity::Error);
200        assert_eq!(rules.unresolved_imports, Severity::Error);
201        assert_eq!(rules.unlisted_dependencies, Severity::Error);
202        assert_eq!(rules.duplicate_exports, Severity::Error);
203        assert_eq!(rules.type_only_dependencies, Severity::Warn);
204        assert_eq!(rules.circular_dependencies, Severity::Error);
205    }
206
207    #[test]
208    fn rules_deserialize_kebab_case() {
209        let json_str = r#"{
210            "unused-files": "error",
211            "unused-exports": "warn",
212            "unused-types": "off"
213        }"#;
214        let rules: RulesConfig = serde_json::from_str(json_str).unwrap();
215        assert_eq!(rules.unused_files, Severity::Error);
216        assert_eq!(rules.unused_exports, Severity::Warn);
217        assert_eq!(rules.unused_types, Severity::Off);
218        // Unset fields default to error
219        assert_eq!(rules.unresolved_imports, Severity::Error);
220    }
221
222    #[test]
223    fn severity_from_str() {
224        assert_eq!("error".parse::<Severity>().unwrap(), Severity::Error);
225        assert_eq!("warn".parse::<Severity>().unwrap(), Severity::Warn);
226        assert_eq!("warning".parse::<Severity>().unwrap(), Severity::Warn);
227        assert_eq!("off".parse::<Severity>().unwrap(), Severity::Off);
228        assert_eq!("none".parse::<Severity>().unwrap(), Severity::Off);
229        assert!("invalid".parse::<Severity>().is_err());
230    }
231
232    #[test]
233    fn apply_partial_only_some_fields() {
234        let mut rules = RulesConfig::default();
235        let partial = PartialRulesConfig {
236            unused_files: Some(Severity::Warn),
237            unused_exports: Some(Severity::Off),
238            ..Default::default()
239        };
240        rules.apply_partial(&partial);
241        assert_eq!(rules.unused_files, Severity::Warn);
242        assert_eq!(rules.unused_exports, Severity::Off);
243        // Unset fields unchanged
244        assert_eq!(rules.unused_types, Severity::Error);
245        assert_eq!(rules.unresolved_imports, Severity::Error);
246    }
247}
fallow_config/config/rules.rs

fallow_config/config/
rules.rs
