chore: configuring rules through config

Author: gvozdvmozgu

crates/lib/src/cli/formatters.rs

@@ -291,16 +291,18 @@ impl Status {
 mod tests {
     use std::fs::File;
 
+    use ahash::AHashMap;
     use anstyle::AnsiColor;
     use fancy_regex::Regex;
     use tempdir::TempDir;
 
     use super::OutputStreamFormatter;
     use crate::cli::formatters::split_string_on_spaces;
+    use crate::core::config::Value;
     use crate::core::errors::SQLLintError;
     use crate::core::parser::markers::PositionMarker;
     use crate::core::parser::segments::raw::RawSegment;
-    use crate::core::rules::base::{Erased, LintResult, Rule};
+    use crate::core::rules::base::{Erased, ErasedRule, LintResult, Rule};
     use crate::core::rules::context::RuleContext;
     use crate::core::rules::crawlers::Crawler;
     use crate::core::templaters::base::TemplatedFile;
@@ -368,6 +370,10 @@ mod tests {
             fn crawl_behaviour(&self) -> Crawler {
                 todo!()
             }
+
+            fn from_config(&self, _config: &AHashMap<String, Value>) -> ErasedRule {
+                unimplemented!()
+            }
         }
 
         let s = RawSegment::new(

crates/lib/src/core/config.rs

@@ -98,8 +98,16 @@ pub fn removed_configs() -> [RemovedConfig<'static>; 12] {
 
 /// split_comma_separated_string takes a string and splits it on commas and
 /// trims and filters out empty strings.
-pub fn split_comma_separated_string(raw_str: &str) -> Vec<String> {
-    raw_str.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect()
+pub fn split_comma_separated_string(raw_str: &str) -> Value {
+    let values = raw_str
+        .split(',')
+        .flat_map(|x| {
+            let trimmed = x.trim();
+            (!trimmed.is_empty()).then(|| Value::String(trimmed.into()))
+        })
+        .collect();
+
+    Value::Array(values)
 }
 
 /// The class that actually gets passed around as a config object.
@@ -125,8 +133,11 @@ impl FluffConfig {
         &self.raw[section][key]
     }
 
+    pub fn get_section(&self, section: &str) -> &AHashMap<String, Value> {
+        &self.raw[section].as_map().unwrap()
+    }
+
     // TODO This is not a translation that is particularly accurate.
-    #[track_caller]
     pub fn new(
         mut configs: AHashMap<String, Value>,
         extra_config_path: Option<String>,
@@ -147,6 +158,30 @@ impl FluffConfig {
 
         ConfigLoader.incorporate_vals(&mut configs, values);
 
+        for (in_key, out_key) in [
+            // Deal with potential ignore & warning parameters
+            ("ignore", "ignore"),
+            ("warnings", "warnings"),
+            ("rules", "rule_allowlist"),
+            // Allowlists and denylistsignore_words
+            ("exclude_rules", "rule_denylist"),
+        ] {
+            match configs["core"].as_map().unwrap().get(in_key) {
+                Some(value) if !value.is_none() => {
+                    let string = value.as_string().unwrap();
+                    let values = split_comma_separated_string(string);
+
+                    configs
+                        .get_mut("core")
+                        .unwrap()
+                        .as_map_mut()
+                        .unwrap()
+                        .insert(out_key.into(), values);
+                }
+                _ => {}
+            }
+        }
+
         Self {
             raw: configs,
             dialect,
@@ -442,9 +477,20 @@ pub enum Value {
     Float(f64),
     String(Box<str>),
     Map(AHashMap<String, Value>),
+    Array(Vec<Value>),
     None,
 }
 
+impl Value {
+    pub fn is_none(&self) -> bool {
+        matches!(self, Value::None)
+    }
+
+    pub fn as_array(&self) -> Option<&[Value]> {
+        if let Self::Array(v) = self { Some(v) } else { None }
+    }
+}
+
 impl Index<&str> for Value {
     type Output = Value;
 
@@ -465,6 +511,7 @@ impl Value {
             Value::String(ref v) => !v.is_empty(),
             Value::Map(ref v) => !v.is_empty(),
             Value::None => false,
+            Value::Array(ref v) => !v.is_empty(),
         }
     }
 

crates/lib/src/core/linter/linter.rs

@@ -22,8 +22,9 @@ use crate::core::parser::lexer::{Lexer, StringOrTemplate};
 use crate::core::parser::parser::Parser;
 use crate::core::parser::segments::base::ErasedSegment;
 use crate::core::parser::segments::fix::AnchorEditInfo;
-use crate::core::rules::base::{ErasedRule, LintFix};
+use crate::core::rules::base::{ErasedRule, LintFix, RulePack};
 use crate::core::templaters::base::{RawTemplater, TemplatedFile, Templater};
+use crate::rules::get_ruleset;
 
 pub struct Linter {
     config: FluffConfig,
@@ -38,7 +39,7 @@ impl Linter {
         formatter: Option<OutputStreamFormatter>,
         templater: Option<Box<dyn Templater>>,
     ) -> Linter {
-        let rules = crate::rules::layout::get_rules(&config);
+        let rules = crate::rules::layout::get_rules();
         match templater {
             Some(templater) => Linter { config, formatter, templater, rules },
             None => Linter { config, formatter, templater: Box::<RawTemplater>::default(), rules },
@@ -180,12 +181,22 @@ impl Linter {
         result
     }
 
+    pub fn get_rulepack(&self) -> RulePack {
+        let rs = get_ruleset();
+        rs.get_rulepack(&self.config)
+    }
+
     pub fn render_file(&mut self, fname: String) -> RenderedFile {
         let in_str = std::fs::read_to_string(&fname).unwrap();
         self.render_string(in_str, fname, self.config.clone(), None).unwrap()
     }
 
-    pub fn lint_rendered(&mut self, rendered: RenderedFile, fix: bool) -> LintedFile {
+    pub fn lint_rendered(
+        &mut self,
+        rendered: RenderedFile,
+        rule_pack: &RulePack,
+        fix: bool,
+    ) -> LintedFile {
         let parsed = Self::parse_rendered(rendered, false);
         self.lint_parsed(parsed, self.rules.clone(), fix)
     }

crates/lib/src/core/linter/runner.rs

@@ -27,10 +27,11 @@ pub struct SequentialRunner;
 impl Runner for SequentialRunner {
     fn run(&mut self, paths: Vec<String>, fix: bool, linter: &mut Linter) -> Vec<LintedFile> {
         let mut acc = Vec::with_capacity(paths.len());
+        let rule_pack = linter.get_rulepack();
 
         for path in paths {
             let rendered = linter.render_file(path);
-            let linted_file = linter.lint_rendered(rendered, fix);
+            let linted_file = linter.lint_rendered(rendered, &rule_pack, fix);
 
             acc.push(linted_file);
         }

crates/lib/src/core/parser/grammar/conditional.rs

@@ -86,8 +86,6 @@ impl Matchable for Conditional {
             return Ok(MatchResult::from_unmatched(segments.to_vec()));
         }
 
-        dbg!(self);
-
         Ok(MatchResult {
             matched_segments: vec![self.meta.clone().to_erased_segment()],
             unmatched_segments: segments.to_vec(),