feat: add RuleOverwrite to override rule severity from CLI

HerringtonDarkholme · HerringtonDarkholme · commit 50bf83d1d7d7 · 2024-10-22T14:59:51.000-04:00
fix ast-grep#1061
diff --git a/crates/cli/src/config.rs b/crates/cli/src/config.rs
@@ -1,13 +1,12 @@
 use crate::lang::{CustomLang, LanguageGlobs, SerializableInjection, SgLang};
-use crate::utils::{ErrorContext as EC, RuleTrace};
+use crate::utils::{ErrorContext as EC, RuleOverwrite, RuleTrace};
 
 use anyhow::{Context, Result};
 use ast_grep_config::{
   from_str, from_yaml_string, DeserializeEnv, GlobalRules, RuleCollection, RuleConfig,
 };
 use ast_grep_language::config_file_type;
 use ignore::WalkBuilder;
-use regex::Regex;
 use serde::{Deserialize, Serialize};
 
 use std::collections::HashMap;
@@ -84,11 +83,11 @@ impl ProjectConfig {
 
 pub fn find_rules(
   config_path: Option<PathBuf>,
-  rule_filter: Option<&Regex>,
+  rule_overwrite: RuleOverwrite,
 ) -> Result<(RuleCollection<SgLang>, RuleTrace)> {
   let project_config = ProjectConfig::by_config_path(config_path)?;
   let global_rules = find_util_rules(&project_config)?;
-  read_directory_yaml(&project_config, global_rules, rule_filter)
+  read_directory_yaml(&project_config, global_rules, rule_overwrite)
 }
 
 pub fn register_custom_language(config_path: Option<PathBuf>) -> Result<()> {
@@ -153,7 +152,7 @@ fn find_util_rules(config: &ProjectConfig) -> Result<GlobalRules<SgLang>> {
 fn read_directory_yaml(
   config: &ProjectConfig,
   global_rules: GlobalRules<SgLang>,
-  rule_filter: Option<&Regex>,
+  rule_overwrite: RuleOverwrite,
 ) -> Result<(RuleCollection<SgLang>, RuleTrace)> {
   let mut configs = vec![];
   let ProjectConfig {
@@ -182,11 +181,7 @@ fn read_directory_yaml(
   }
   let total_rule_count = configs.len();
 
-  let configs = if let Some(filter) = rule_filter {
-    filter_rule_by_regex(configs, filter)?
-  } else {
-    configs
-  };
+  let configs = rule_overwrite.process_configs(configs)?;
   let collection = RuleCollection::try_new(configs).context(EC::GlobPattern)?;
   let effective_rule_count = collection.total_rule_count();
   let trace = RuleTrace {
@@ -196,22 +191,6 @@ fn read_directory_yaml(
   Ok((collection, trace))
 }
 
-fn filter_rule_by_regex(
-  configs: Vec<RuleConfig<SgLang>>,
-  filter: &Regex,
-) -> Result<Vec<RuleConfig<SgLang>>> {
-  let selected: Vec<_> = configs
-    .into_iter()
-    .filter(|c| filter.is_match(&c.id))
-    .collect();
-
-  if selected.is_empty() {
-    Err(anyhow::anyhow!(EC::RuleNotFound(filter.to_string())))
-  } else {
-    Ok(selected)
-  }
-}
-
 pub fn read_rule_file(
   path: &Path,
   global_rules: Option<&GlobalRules<SgLang>>,
diff --git a/crates/cli/src/lsp.rs b/crates/cli/src/lsp.rs
@@ -24,7 +24,7 @@ async fn run_language_server_impl(arg: LspArg) -> Result<()> {
   let stdin = tokio::io::stdin();
   let stdout = tokio::io::stdout();
   let config_base = find_config_base(arg.config.clone())?;
-  let config_result = find_rules(arg.config, None);
+  let config_result = find_rules(arg.config, Default::default());
   let config_result_std: std::result::Result<_, String> = config_result
     .map_err(|e| {
       // convert anyhow::Error to String with chain of causes
diff --git a/crates/cli/src/scan.rs b/crates/cli/src/scan.rs
@@ -17,6 +17,7 @@ use crate::print::{
   ReportStyle, SimpleFile,
 };
 use crate::utils::ErrorContext as EC;
+use crate::utils::RuleOverwrite;
 use crate::utils::{filter_file_interactive, InputArgs, OutputArgs, SeverityArg};
 use crate::utils::{FileTrace, RuleTrace, ScanTrace};
 use crate::utils::{Items, PathWorker, StdInWorker, Worker};
@@ -120,7 +121,8 @@ impl<P: Printer> ScanWithConfig<P> {
         .with_context(|| EC::ParseRule("INLINE_RULES".into()))?;
       RuleCollection::try_new(rules).context(EC::GlobPattern)?
     } else {
-      let (configs, r_stats) = find_rules(arg.config.take(), arg.filter.as_ref())?;
+      let overwrite = RuleOverwrite::new(&arg.severity, &arg.filter)?;
+      let (configs, r_stats) = find_rules(arg.config.take(), overwrite)?;
       rule_trace = r_stats;
       configs
     };
diff --git a/crates/cli/src/utils/mod.rs b/crates/cli/src/utils/mod.rs
@@ -8,6 +8,7 @@ mod worker;
 pub use args::{InputArgs, OutputArgs, SeverityArg};
 pub use debug_query::DebugFormat;
 pub use error_context::{exit_with_error, ErrorContext};
+pub use rule_overwrite::RuleOverwrite;
 pub use tracing::{FileTrace, RuleTrace, RunTrace, ScanTrace, Tracing};
 pub use worker::{Items, PathWorker, StdInWorker, Worker};
 
diff --git a/crates/cli/src/utils/rule_overwrite.rs b/crates/cli/src/utils/rule_overwrite.rs
@@ -1,14 +1,19 @@
 use super::SeverityArg;
+use crate::lang::SgLang;
+use crate::utils::ErrorContext as EC;
 
 use anyhow::Result;
-use ast_grep_config::{SerializableRuleConfig, Severity};
+use ast_grep_config::{RuleConfig, Severity};
 use ast_grep_core::Language;
+use regex::Regex;
 
 use std::collections::HashMap;
 
-struct RuleOverwrite {
+#[derive(Default)]
+pub struct RuleOverwrite {
   default_severity: Option<Severity>,
   by_rule_id: HashMap<String, Severity>,
+  rule_filter: Option<Regex>,
 }
 
 fn read_severity(
@@ -28,7 +33,7 @@ fn read_severity(
 }
 
 impl RuleOverwrite {
-  pub fn new(cli: SeverityArg) -> Result<Self> {
+  pub fn new(cli: &SeverityArg, filter: &Option<Regex>) -> Result<Self> {
     let mut default_severity = None;
     let mut by_rule_id = HashMap::new();
     read_severity(
@@ -64,10 +69,27 @@ impl RuleOverwrite {
     Ok(Self {
       default_severity,
       by_rule_id,
+      rule_filter: filter.clone(),
     })
   }
 
-  pub fn find(&self, id: &str) -> OverwriteResult {
+  pub fn process_configs(
+    &self,
+    configs: Vec<RuleConfig<SgLang>>,
+  ) -> Result<Vec<RuleConfig<SgLang>>> {
+    let mut configs = if let Some(filter) = &self.rule_filter {
+      filter_rule_by_regex(configs, filter)?
+    } else {
+      configs
+    };
+    for config in &mut configs {
+      let overwrite = self.find(&config.id);
+      overwrite.overwrite(config);
+    }
+    Ok(configs)
+  }
+
+  fn find(&self, id: &str) -> OverwriteResult {
     let severity = self
       .by_rule_id
       .get(id)
@@ -77,12 +99,28 @@ impl RuleOverwrite {
   }
 }
 
-pub struct OverwriteResult {
-  pub severity: Option<Severity>,
+fn filter_rule_by_regex(
+  configs: Vec<RuleConfig<SgLang>>,
+  filter: &Regex,
+) -> Result<Vec<RuleConfig<SgLang>>> {
+  let selected: Vec<_> = configs
+    .into_iter()
+    .filter(|c| filter.is_match(&c.id))
+    .collect();
+
+  if selected.is_empty() {
+    Err(anyhow::anyhow!(EC::RuleNotFound(filter.to_string())))
+  } else {
+    Ok(selected)
+  }
+}
+
+struct OverwriteResult {
+  severity: Option<Severity>,
 }
 
 impl OverwriteResult {
-  pub fn overwrite<L>(&self, rule: &mut SerializableRuleConfig<L>)
+  fn overwrite<L>(&self, rule: &mut RuleConfig<L>)
   where
     L: Language,
   {
diff --git a/crates/cli/src/verify.rs b/crates/cli/src/verify.rs
@@ -57,7 +57,7 @@ where
 }
 
 fn run_test_rule_impl<R: Reporter + Send>(arg: TestArg, reporter: R) -> Result<()> {
-  let collections = &find_rules(arg.config.clone(), None)?.0;
+  let collections = &find_rules(arg.config.clone(), Default::default())?.0;
   let TestHarness {
     test_cases,
     snapshots,
diff --git a/crates/config/src/rule_config.rs b/crates/config/src/rule_config.rs
@@ -208,6 +208,12 @@ impl<L: Language> Deref for RuleConfig<L> {
   }
 }
 
+impl<L: Language> DerefMut for RuleConfig<L> {
+  fn deref_mut(&mut self) -> &mut Self::Target {
+    &mut self.inner
+  }
+}
+
 #[cfg(test)]
 mod test {
   use super::*;

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ where`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`fn run_test_rule_impl<R: Reporter + Send>(arg: TestArg, reporter: R) -> Result<()> {`
`60`		`- let collections = &find_rules(arg.config.clone(), None)?.0;`
	`60`	`+ let collections = &find_rules(arg.config.clone(), Default::default())?.0;`
`61`	`61`	`let TestHarness {`
`62`	`62`	`test_cases,`
`63`	`63`	`snapshots,`
Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,12 @@ impl<L: Language> Deref for RuleConfig<L> {`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
	`211`	`+impl<L: Language> DerefMut for RuleConfig<L> {`
	`212`	`+ fn deref_mut(&mut self) -> &mut Self::Target {`
	`213`	`+ &mut self.inner`
	`214`	`+ }`
	`215`	`+}`
	`216`	`+`
`211`	`217`	`#[cfg(test)]`
`212`	`218`	`mod test {`
`213`	`219`	`use super::*;`