feat(splinter): allow ignoring db objects (#634)

adds an `ignores` config option to all `splinter` rules.

the filter is applied in rust and not part of the query for more
flexibility.

also: moved `matcher` into its own crate to allow `splinter` to reuse it

Author: psteinroe

Cargo.lock

@@ -77,6 +77,7 @@ pgls_lexer                  = { path = "./crates/pgls_lexer", version = "0.0.0"
 pgls_lexer_codegen          = { path = "./crates/pgls_lexer_codegen", version = "0.0.0" }
 pgls_lsp                    = { path = "./crates/pgls_lsp", version = "0.0.0" }
 pgls_markup                 = { path = "./crates/pgls_markup", version = "0.0.0" }
+pgls_matcher                = { path = "./crates/pgls_matcher", version = "0.0.0" }
 pgls_plpgsql_check          = { path = "./crates/pgls_plpgsql_check", version = "0.0.0" }
 pgls_query                  = { path = "./crates/pgls_query", version = "0.0.0" }
 pgls_query_ext              = { path = "./crates/pgls_query_ext", version = "0.0.0" }

Cargo.toml

@@ -22,6 +22,7 @@ pgls_analyser            = { workspace = true }
 pgls_console             = { workspace = true }
 pgls_diagnostics         = { workspace = true }
 pgls_env                 = { workspace = true }
+pgls_matcher             = { workspace = true }
 pgls_text_size           = { workspace = true }
 rustc-hash               = { workspace = true }
 schemars                 = { workspace = true, features = ["indexmap1"], optional = true }

crates/pgls_configuration/Cargo.toml

@@ -58,6 +58,15 @@ impl<T: Clone + Default + 'static> RuleConfiguration<T> {
         }
     }
 }
+impl<T: Default> RuleConfiguration<T> {
+    /// Get a reference to the typed options if present
+    pub fn get_options_ref(&self) -> Option<&T> {
+        match self {
+            Self::Plain(_) => None,
+            Self::WithOptions(options) => Some(&options.options),
+        }
+    }
+}
 impl<T: Default> Default for RuleConfiguration<T> {
     fn default() -> Self {
         Self::Plain(RulePlainConfiguration::Error)

crates/pgls_configuration/src/rules/configuration.rs

@@ -1,6 +1,8 @@
 //! Generated file, do not edit by hand, see `xtask/codegen`
 
 #![doc = r" Generated file, do not edit by hand, see `xtask/codegen`"]
+mod options;
+pub use options::SplinterRuleOptions;
 mod rules;
 use biome_deserialize::StringSet;
 use biome_deserialize_macros::{Merge, Partial};

crates/pgls_configuration/src/splinter/mod.rs

@@ -0,0 +1,25 @@
+use biome_deserialize_macros::Deserializable;
+#[cfg(feature = "schema")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Shared options for all splinter rules.
+///
+/// These options allow configuring per-rule filtering of database objects.
+#[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, PartialEq, Serialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct SplinterRuleOptions {
+    /// A list of glob patterns for database objects to ignore.
+    ///
+    /// Patterns use Unix-style globs where:
+    /// - `*` matches any sequence of characters
+    /// - `?` matches any single character
+    ///
+    /// Each pattern should be in the format `schema.object_name`, for example:
+    /// - `"public.my_table"` - ignores a specific table
+    /// - `"audit.*"` - ignores all objects in the audit schema
+    /// - `"*.audit_*"` - ignores objects with audit_ prefix in any schema
+    #[serde(default)]
+    pub ignore: Vec<String>,
+}

crates/pgls_configuration/src/splinter/options.rs

@@ -0,0 +1,16 @@
+[package]
+authors.workspace    = true
+categories.workspace = true
+description          = "Unix shell style pattern matching for Postgres Language Server"
+edition.workspace    = true
+homepage.workspace   = true
+keywords.workspace   = true
+license.workspace    = true
+name                 = "pgls_matcher"
+repository.workspace = true
+version              = "0.0.0"
+
+[dependencies]
+pgls_console     = { workspace = true }
+pgls_diagnostics = { workspace = true }
+rustc-hash       = { workspace = true }

crates/pgls_configuration/src/splinter/rules.rs

@@ -135,8 +135,8 @@ impl Diagnostic for PatternError {
 
 #[cfg(test)]
 mod test {
-    use crate::matcher::Matcher;
-    use crate::matcher::pattern::MatchOptions;
+    use crate::Matcher;
+    use crate::pattern::MatchOptions;
     use std::env;
 
     #[test]
@@ -145,7 +145,7 @@ mod test {
         let dir = format!("{}/**/*.rs", current.display());
         let mut ignore = Matcher::new(MatchOptions::default());
         ignore.add_pattern(&dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches(path.to_str().unwrap());
 
         assert!(result);
@@ -157,7 +157,7 @@ mod test {
         let dir = format!("{}/**/*.rs", current.display());
         let mut ignore = Matcher::new(MatchOptions::default());
         ignore.add_pattern(&dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches_path(path.as_path());
 
         assert!(result);
@@ -184,14 +184,14 @@ mod test {
 
     #[test]
     fn matches_single_path() {
-        let dir = "workspace.rs";
+        let dir = "lib.rs";
         let mut ignore = Matcher::new(MatchOptions {
             require_literal_separator: true,
             case_sensitive: true,
             require_literal_leading_dot: true,
         });
         ignore.add_pattern(dir).unwrap();
-        let path = env::current_dir().unwrap().join("src/workspace.rs");
+        let path = env::current_dir().unwrap().join("src/lib.rs");
         let result = ignore.matches(path.to_str().unwrap());
 
         assert!(result);

crates/pgls_matcher/Cargo.toml

@@ -1,8 +1,6 @@
-use crate::matcher::pattern::CharSpecifier::{CharRange, SingleChar};
-use crate::matcher::pattern::MatchResult::{
-    EntirePatternDoesntMatch, Match, SubPatternDoesntMatch,
-};
-use crate::matcher::pattern::PatternToken::{
+use crate::pattern::CharSpecifier::{CharRange, SingleChar};
+use crate::pattern::MatchResult::{EntirePatternDoesntMatch, Match, SubPatternDoesntMatch};
+use crate::pattern::PatternToken::{
     AnyChar, AnyExcept, AnyPattern, AnyRecursiveSequence, AnySequence, AnyWithin, Char,
 };
 use std::error::Error;