test and fix options

Author: psteinroe

Cargo.lock

@@ -95,7 +95,6 @@ pub trait Rule: RuleMeta + Sized {
 
 /// Diagnostic object returned by a single analysis rule
 #[derive(Debug, Diagnostic)]
-#[diagnostic(severity = Warning)]
 pub struct RuleDiagnostic {
     #[category]
     pub(crate) category: &'static Category,

crates/pg_analyse/src/rule.rs

@@ -15,3 +15,4 @@ version              = "0.0.0"
 pg_analyse   = { workspace = true }
 pg_console   = { workspace = true }
 pg_query_ext = { workspace = true }
+serde        = { workspace = true }

crates/pg_analyser/Cargo.toml

@@ -1,6 +1,13 @@
 use pg_analyse::{context::RuleContext, declare_lint_rule, Rule, RuleDiagnostic, RuleSource};
 use pg_console::markup;
 
+#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+// #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", deny_unknown_fields, default)]
+pub struct Options {
+    test: String,
+}
+
 declare_lint_rule! {
     /// Dropping a column may break existing clients.
     ///
@@ -25,7 +32,7 @@ declare_lint_rule! {
 }
 
 impl Rule for BanDropColumn {
-    type Options = ();
+    type Options = Options;
 
     fn run(ctx: &RuleContext<Self>) -> Vec<RuleDiagnostic> {
         let mut diagnostics = Vec::new();
@@ -40,7 +47,7 @@ impl Rule for BanDropColumn {
                             markup! {
                                 "Dropping a column may break existing clients."
                             },
-                        ).detail(None, "You can leave the column as nullable or delete the column once queries no longer select or modify the column."));
+                        ).detail(None, format!("[{}] You can leave the column as nullable or delete the column once queries no longer select or modify the column.", ctx.options().test)));
                     }
                 }
             }

crates/pg_analyser/src/lint/safety/ban_drop_column.rs

@@ -1,4 +1,5 @@
 use biome_deserialize::StringSet;
+use pg_diagnostics::Category;
 use std::{
     borrow::Cow,
     num::NonZeroU64,
@@ -110,6 +111,20 @@ impl Settings {
     pub fn as_linter_rules(&self) -> Option<Cow<pg_configuration::analyser::linter::Rules>> {
         self.linter.rules.as_ref().map(Cow::Borrowed)
     }
+
+    /// It retrieves the severity based on the `code` of the rule and the current configuration.
+    ///
+    /// The code of the has the following pattern: `{group}/{rule_name}`.
+    ///
+    /// It returns [None] if the `code` doesn't match any rule.
+    pub fn get_severity_from_rule_code(&self, code: &Category) -> Option<pg_diagnostics::Severity> {
+        let rules = self.linter.rules.as_ref();
+        if let Some(rules) = rules {
+            rules.get_severity_from_code(code)
+        } else {
+            None
+        }
+    }
 }
 
 fn to_linter_settings(

crates/pg_workspace_new/src/settings.rs

@@ -317,14 +317,16 @@ impl Workspace for WorkspaceServer {
             .get(&params.path)
             .ok_or(WorkspaceError::not_found())?;
 
+        let settings = self.settings();
+
         // create analyser for this run
         // first, collect enabled and disabled rules from the workspace settings
-        let (enabled_rules, disabled_rules) = AnalyserVisitorBuilder::new(self.settings().as_ref())
+        let (enabled_rules, disabled_rules) = AnalyserVisitorBuilder::new(settings.as_ref())
             .with_linter_rules(&params.only, &params.skip)
             .finish();
         // then, build a map that contains all options
         let options = AnalyserOptions {
-            rules: to_analyser_rules(self.settings().as_ref()),
+            rules: to_analyser_rules(settings.as_ref()),
         };
         // next, build the analysis filter which will be used to match rules
         let filter = AnalysisFilter {
@@ -359,9 +361,25 @@ impl Workspace for WorkspaceServer {
                 stmt_diagnostics
                     .into_iter()
                     .map(|d| {
+                        // We do now check if the severity of the diagnostics should be changed.
+                        // The configuration allows to change the severity of the diagnostics emitted by rules.
+                        let severity = d
+                            .category()
+                            .filter(|category| category.name().starts_with("lint/"))
+                            .map_or_else(
+                                || d.severity(),
+                                |category| {
+                                    settings
+                                        .as_ref()
+                                        .get_severity_from_rule_code(category)
+                                        .unwrap_or(Severity::Warning)
+                                },
+                            );
+
                         SDiagnostic::new(
                             d.with_file_path(params.path.as_path().display().to_string())
-                                .with_file_span(r),
+                                .with_file_span(r)
+                                .with_severity(severity),
                         )
                     })
                     .collect::<Vec<_>>()

crates/pg_workspace_new/src/workspace/server.rs

@@ -12,3 +12,15 @@ port = 54322
 username = "postgres"
 password = "postgres"
 database = "postgres"
+
+[linter]
+enabled = true
+
+[linter.rules]
+recommended = true
+
+[linter.rules.safety.banDropColumn]
+level = "warn"
+options = { test = "HELLO" }
+
+