merged

Author: juleswritescode

crates/pgt_configuration/src/analyser/linter/rules.rs

@@ -121,6 +121,14 @@ impl Rules {
         }
         enabled_rules.difference(&disabled_rules).copied().collect()
     }
+    #[doc = r" It returns the disabled rules by configuration."]
+    pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+        let mut disabled_rules = FxHashSet::default();
+        if let Some(group) = self.safety.as_ref() {
+            disabled_rules.extend(&group.get_disabled_rules());
+        }
+        disabled_rules
+    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Eq, Merge, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]

crates/pgt_workspace/src/workspace/server/analyser.rs

@@ -79,6 +79,13 @@ impl<'a, 'b> LintVisitor<'a, 'b> {
                 .unwrap_or_default();
 
             self.enabled_rules.extend(enabled_rules);
+
+            let disabled_rules = self
+                .settings
+                .as_linter_rules()
+                .map(|rules| rules.as_disabled_rules())
+                .unwrap_or_default();
+            self.disabled_rules.extend(disabled_rules);
         }
 
         (self.enabled_rules, self.disabled_rules)
@@ -135,6 +142,7 @@ impl RegistryVisitor for LintVisitor<'_, '_> {
 
 #[cfg(test)]
 mod tests {
+    use pgt_analyse::RuleFilter;
     use pgt_configuration::{RuleConfiguration, Rules, analyser::Safety};
 
     use crate::{
@@ -143,11 +151,10 @@ mod tests {
     };
 
     #[test]
-    fn identifies_disabled_rules() {
+    fn recognizes_disabled_rules() {
         let settings = Settings {
             linter: LinterSettings {
                 rules: Some(Rules {
-                    recommended: Some(true),
                     safety: Some(Safety {
                         ban_drop_column: Some(RuleConfiguration::Plain(
                             pgt_configuration::RulePlainConfiguration::Off,
@@ -156,17 +163,18 @@ mod tests {
                     }),
                     ..Default::default()
                 }),
-
                 ..Default::default()
             },
             ..Default::default()
         };
 
-        let (enabled_rules, disabled_rules) = AnalyserVisitorBuilder::new(&settings)
+        let (_, disabled_rules) = AnalyserVisitorBuilder::new(&settings)
             .with_linter_rules(&[], &[])
             .finish();
 
-        println!("{:#?}", enabled_rules);
-        println!("{:#?}", disabled_rules);
+        assert_eq!(
+            disabled_rules,
+            vec![RuleFilter::Rule("safety", "banDropColumn")]
+        )
     }
 }

xtask/codegen/src/generate_configuration.rs

@@ -61,6 +61,8 @@ fn generate_for_groups(
     let mut group_idents = Vec::with_capacity(groups.len());
     let mut group_strings = Vec::with_capacity(groups.len());
     let mut group_as_default_rules = Vec::with_capacity(groups.len());
+    let mut group_as_disabled_rules = Vec::with_capacity(groups.len());
+
     for (group, rules) in groups {
         let group_pascal_ident = quote::format_ident!("{}", &Case::Pascal.convert(group));
         let group_ident = quote::format_ident!("{}", group);
@@ -95,6 +97,12 @@ fn generate_for_groups(
             }
         });
 
+        group_as_disabled_rules.push(quote! {
+            if let Some(group) = self.#group_ident.as_ref() {
+                disabled_rules.extend(&group.get_disabled_rules());
+            }
+        });
+
         group_pascal_idents.push(group_pascal_ident);
         group_idents.push(group_ident);
         group_strings.push(Literal::string(group));
@@ -246,6 +254,13 @@ fn generate_for_groups(
                     #( #group_as_default_rules )*
                     enabled_rules
                 }
+
+                /// It returns the disabled rules by configuration.
+                pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+                    let mut disabled_rules = FxHashSet::default();
+                    #( #group_as_disabled_rules )*
+                    disabled_rules
+                }
             }
 
             #( #struct_groups )*
@@ -358,6 +373,13 @@ fn generate_for_groups(
 
                     enabled_rules.difference(&disabled_rules).copied().collect()
                 }
+
+                /// It returns the disabled rules by configuration.
+                pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+                    let mut disabled_rules = FxHashSet::default();
+                    #( #group_as_disabled_rules )*
+                    disabled_rules
+                }
             }
 
             #( #struct_groups )*