use fallow_types::workspace::{OVERRIDE_REASON_BASE_RULE_OFF, OVERRIDE_REASON_PROJECT_LEVEL};
use super::ResolvedConfig;
use super::rules::{PartialRulesConfig, RulesConfig, Severity};
type OverrideSeverity = fn(&PartialRulesConfig) -> Option<Severity>;
type TopLevelSeverity = fn(&RulesConfig) -> Severity;
const PROJECT_LEVEL_RULES: [(&str, bool, OverrideSeverity); 11] = [
("unused-dependencies", true, |r| r.unused_dependencies),
("unused-dev-dependencies", true, |r| {
r.unused_dev_dependencies
}),
("unused-optional-dependencies", true, |r| {
r.unused_optional_dependencies
}),
("unlisted-dependencies", true, |r| r.unlisted_dependencies),
("unlisted-binaries", false, |r| r.unlisted_binaries),
("type-only-dependencies", true, |r| r.type_only_dependencies),
("test-only-dependencies", true, |r| r.test_only_dependencies),
("dev-dependencies-in-production", true, |r| {
r.dev_dependencies_in_production
}),
("duplicate-exports", false, |r| r.duplicate_exports),
("re-export-cycle", false, |r| r.re_export_cycle),
("unused-catalog-entries", false, |r| {
r.unused_catalog_entries
}),
];
const BASE_GATED_RULES: [(&str, OverrideSeverity, TopLevelSeverity); 9] = [
("unused-files", |r| r.unused_files, |r| r.unused_files),
("unused-exports", |r| r.unused_exports, |r| r.unused_exports),
("unused-types", |r| r.unused_types, |r| r.unused_types),
(
"private-type-leaks",
|r| r.private_type_leaks,
|r| r.private_type_leaks,
),
(
"unused-enum-members",
|r| r.unused_enum_members,
|r| r.unused_enum_members,
),
(
"unused-class-members",
|r| r.unused_class_members,
|r| r.unused_class_members,
),
(
"unresolved-imports",
|r| r.unresolved_imports,
|r| r.unresolved_imports,
),
(
"circular-dependencies",
|r| r.circular_dependencies,
|r| r.circular_dependencies,
),
(
"deprecated-exports-in-use",
|r| r.deprecated_exports_in_use,
|r| r.deprecated_exports_in_use,
),
];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IneffectiveOverrideRule {
pub rule: &'static str,
pub files: Vec<String>,
pub reason: &'static str,
pub dependency_rule: bool,
}
#[must_use]
pub fn project_level_override_rules(rules: &PartialRulesConfig) -> Vec<&'static str> {
PROJECT_LEVEL_RULES
.iter()
.filter(|(_, _, severity)| severity(rules).is_some())
.map(|(name, _, _)| *name)
.collect()
}
pub(super) fn key_sets_rule(key: &str, rule: &str) -> bool {
let map = serde_json::json!({ key: "off" });
let Ok(rules) = serde_json::from_value::<PartialRulesConfig>(map) else {
return false;
};
let in_project_level = PROJECT_LEVEL_RULES
.iter()
.any(|(name, _, severity)| *name == rule && severity(&rules).is_some());
in_project_level
|| BASE_GATED_RULES
.iter()
.any(|(name, severity, _)| *name == rule && severity(&rules).is_some())
}
impl ResolvedConfig {
#[must_use]
pub fn ineffective_override_rules(&self) -> Vec<IneffectiveOverrideRule> {
let mut entries: Vec<IneffectiveOverrideRule> = Vec::new();
for entry in &self.overrides {
let project_level = PROJECT_LEVEL_RULES
.iter()
.filter(|(_, _, severity)| severity(&entry.rules).is_some())
.map(|(name, dependency_rule, _)| IneffectiveOverrideRule {
rule: name,
files: entry.files.clone(),
reason: OVERRIDE_REASON_PROJECT_LEVEL,
dependency_rule: *dependency_rule,
});
let base_off = BASE_GATED_RULES
.iter()
.filter(|(_, severity, top_level)| {
top_level(&self.rules) == Severity::Off
&& severity(&entry.rules).is_some_and(|value| value != Severity::Off)
})
.map(|(name, _, _)| IneffectiveOverrideRule {
rule: name,
files: entry.files.clone(),
reason: OVERRIDE_REASON_BASE_RULE_OFF,
dependency_rule: false,
});
for candidate in project_level.chain(base_off) {
if !entries.contains(&candidate) {
entries.push(candidate);
}
}
}
entries
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_alias_key_sets_the_canonical_rule() {
assert!(key_sets_rule(
"dev-dependency-in-production",
"dev-dependencies-in-production"
));
assert!(key_sets_rule(
"dev-dependencies-in-production",
"dev-dependencies-in-production"
));
assert!(key_sets_rule("unused-file", "unused-files"));
assert!(!key_sets_rule("unused-files", "unused-exports"));
assert!(!key_sets_rule("not-a-rule", "unused-files"));
}
#[test]
fn the_two_tables_share_no_rule() {
for (name, _, _) in PROJECT_LEVEL_RULES {
assert!(
!BASE_GATED_RULES.iter().any(|(base, _, _)| *base == name),
"{name} would get two reasons"
);
}
}
}