test(analyser): add debug_test

crates/pglt_analyse/src/rule.rs

@@ -94,7 +94,7 @@ pub trait Rule: RuleMeta + Sized {
 }
 
 /// Diagnostic object returned by a single analysis rule
-#[derive(Debug, Diagnostic)]
+#[derive(Debug, Diagnostic, PartialEq)]
 pub struct RuleDiagnostic {
     #[category]
     pub(crate) category: &'static Category,
@@ -109,7 +109,7 @@ pub struct RuleDiagnostic {
     pub(crate) rule_advice: RuleAdvice,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq)]
 /// It contains possible advices to show when printing a diagnostic that belong to the rule
 pub struct RuleAdvice {
     pub(crate) details: Vec<Detail>,
@@ -118,7 +118,7 @@ pub struct RuleAdvice {
     pub(crate) code_suggestion_list: Vec<CodeSuggestionAdvice<MarkupBuf>>,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq)]
 pub struct SuggestionList {
     pub(crate) message: MarkupBuf,
     pub(crate) list: Vec<MarkupBuf>,
@@ -160,7 +160,7 @@ impl Advices for RuleAdvice {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Detail {
     pub log_category: LogCategory,
     pub message: MarkupBuf,

crates/pglt_analyser/CONTRIBUTING.md

@@ -280,6 +280,20 @@ This will cause the documentation generator to ensure the rule does emit
 exactly one diagnostic for this code, and to include a snapshot for the
 diagnostic in the resulting documentation page.
 
+### Testing the Rule
+
+#### Quick Test
+
+To quickly test your rule, head to the `pglt_analyser/src/lib.rs` file and modify the `debug_test` function.
+
+You should:
+
+- remove the `#[ignore]` macro if present
+- change the content of the `SQL` static `&str` to whatever you need
+- pass your group and rule to the `RuleFilter::Rule(..)`
+
+If you run the test, you'll see any diagnostics your rule created in your console.
+
 ### Code generation
 
 For simplicity, use `just` to run all the commands with:

crates/pglt_analyser/Cargo.toml

@@ -16,3 +16,7 @@ pglt_analyse   = { workspace = true }
 pglt_console   = { workspace = true }
 pglt_query_ext = { workspace = true }
 serde          = { workspace = true }
+
+[dev-dependencies]
+pglt_diagnostics = { workspace = true }
+termcolor        = { workspace = true }

crates/pglt_analyser/src/lib.rs

@@ -65,3 +65,61 @@ impl<'a> Analyser<'a> {
             .collect::<Vec<_>>()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use core::slice;
+
+    use pglt_analyse::{AnalyserOptions, AnalysisFilter, RuleFilter};
+    use pglt_console::{
+        fmt::{Formatter, Termcolor},
+        markup, Markup,
+    };
+    use pglt_diagnostics::PrintDiagnostic;
+    use termcolor::NoColor;
+
+    use crate::Analyser;
+
+    #[ignore]
+    #[test]
+    fn debug_test() {
+        fn markup_to_string(markup: Markup) -> String {
+            let mut buffer = Vec::new();
+            let mut write = Termcolor(NoColor::new(&mut buffer));
+            let mut fmt = Formatter::new(&mut write);
+            fmt.write_markup(markup).unwrap();
+
+            String::from_utf8(buffer).unwrap()
+        }
+
+        const SQL: &str = r#"alter table test drop column id;"#;
+        let rule_filter = RuleFilter::Rule("safety", "banDropColumn");
+
+        let filter = AnalysisFilter {
+            enabled_rules: Some(slice::from_ref(&rule_filter)),
+            ..Default::default()
+        };
+
+        let ast = pglt_query_ext::parse(SQL).expect("failed to parse SQL");
+
+        let options = AnalyserOptions::default();
+
+        let analyser = Analyser::new(crate::AnalyserConfig {
+            options: &options,
+            filter,
+        });
+
+        let results = analyser.run(crate::AnalyserContext { root: &ast });
+
+        println!("*******************");
+        for result in &results {
+            let text = markup_to_string(markup! {
+                {PrintDiagnostic::simple(result)}
+            });
+            eprintln!("{}", text);
+        }
+        println!("*******************");
+
+        // assert_eq!(results, vec![]);
+    }
+}

crates/pglt_diagnostics/src/advice.rs

@@ -195,7 +195,7 @@ where
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 /// Utility type implementing [Advices] that emits a
 /// code suggestion with the provided text
 pub struct CodeSuggestionAdvice<M> {

crates/pglt_diagnostics/src/display/message.rs

@@ -18,7 +18,7 @@ use termcolor::NoColor;
 ///     message: MessageAndDescription
 /// }
 /// ```
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Deserialize, Serialize, PartialEq)]
 pub struct MessageAndDescription {
     /// Shown when medium supports custom markup
     message: MarkupBuf,