feat(splinter): add global ignore configuration

Add top-level `ignore` field to splinter configuration that applies to
all rules, in addition to existing per-rule ignore.

Example configuration:
```json
{
  "splinter": {
    "ignore": ["audit.*", "temp_*"],
    "rules": { ... }
  }
}
```

Author: psteinroe

Cargo.lock

@@ -4,6 +4,7 @@
 mod options;
 pub use options::SplinterRuleOptions;
 mod rules;
+use biome_deserialize::StringSet;
 use biome_deserialize_macros::{Merge, Partial};
 use bpaf::Bpaf;
 pub use rules::*;
@@ -16,6 +17,11 @@ pub struct SplinterConfiguration {
     #[doc = r" if `false`, it disables the feature and the linter won't be executed. `true` by default"]
     #[partial(bpaf(hide))]
     pub enabled: bool,
+    #[doc = r" A list of glob patterns for database objects to ignore across all rules."]
+    #[doc = r" Patterns use Unix-style globs where `*` matches any sequence of characters."]
+    #[doc = r#" Format: `schema.object_name`, e.g., "public.my_table", "audit.*""#]
+    #[partial(bpaf(hide))]
+    pub ignore: StringSet,
     #[doc = r" List of rules"]
     #[partial(bpaf(pure(Default::default()), optional, hide))]
     pub rules: Rules,
@@ -24,11 +30,24 @@ impl SplinterConfiguration {
     pub const fn is_disabled(&self) -> bool {
         !self.enabled
     }
+    #[doc = r" Build a matcher from the global ignore patterns."]
+    #[doc = r" Returns None if no patterns are configured."]
+    pub fn get_global_ignore_matcher(&self) -> Option<pgls_matcher::Matcher> {
+        if self.ignore.is_empty() {
+            return None;
+        }
+        let mut m = pgls_matcher::Matcher::new(pgls_matcher::MatchOptions::default());
+        for p in self.ignore.iter() {
+            let _ = m.add_pattern(p);
+        }
+        Some(m)
+    }
 }
 impl Default for SplinterConfiguration {
     fn default() -> Self {
         Self {
             enabled: true,
+            ignore: Default::default(),
             rules: Default::default(),
         }
     }

crates/pgls_configuration/src/splinter/mod.rs

@@ -21,9 +21,10 @@ serde_json.workspace         = true
 sqlx.workspace               = true
 
 [dev-dependencies]
-insta.workspace           = true
-pgls_console.workspace    = true
-pgls_test_utils.workspace = true
+biome_deserialize.workspace = true
+insta.workspace             = true
+pgls_console.workspace      = true
+pgls_test_utils.workspace   = true
 
 [lib]
 doctest = false

crates/pgls_splinter/Cargo.toml

@@ -6,7 +6,7 @@ pub mod rule;
 pub mod rules;
 
 use pgls_analyse::{AnalysisFilter, RegistryVisitor, RuleMeta};
-use pgls_configuration::splinter::Rules;
+use pgls_configuration::splinter::SplinterConfiguration;
 use pgls_schema_cache::SchemaCache;
 use sqlx::PgPool;
 
@@ -18,8 +18,8 @@ pub use rule::SplinterRule;
 pub struct SplinterParams<'a> {
     pub conn: &'a PgPool,
     pub schema_cache: Option<&'a SchemaCache>,
-    /// Optional rules configuration for per-rule database object filtering
-    pub rules_config: Option<&'a Rules>,
+    /// Optional splinter configuration for global and per-rule database object filtering
+    pub config: Option<&'a SplinterConfiguration>,
 }
 
 /// Visitor that collects enabled splinter rules based on filter
@@ -138,24 +138,36 @@ pub async fn run_splinter(
 
     let mut diagnostics: Vec<SplinterDiagnostic> = results.into_iter().map(Into::into).collect();
 
-    if let Some(rules_config) = params.rules_config {
-        let rule_matchers = rules_config.get_ignore_matchers();
+    if let Some(config) = params.config {
+        // Build global ignore matcher if patterns exist
+        let global_ignore_matcher = config.get_global_ignore_matcher();
 
-        if !rule_matchers.is_empty() {
+        // Get per-rule ignore matchers
+        let rule_matchers = config.rules.get_ignore_matchers();
+
+        // Filter diagnostics based on global and per-rule ignore patterns
+        if global_ignore_matcher.is_some() || !rule_matchers.is_empty() {
             diagnostics.retain(|diag| {
-                let rule_name = diag.category.name().split('/').next_back().unwrap_or("");
+                let object_identifier = match (&diag.advices.schema, &diag.advices.object_name) {
+                    (Some(schema), Some(name)) => format!("{schema}.{name}"),
+                    _ => return true, // Keep diagnostics without schema.name
+                };
+
+                // Check global ignore first
+                if let Some(ref matcher) = global_ignore_matcher {
+                    if matcher.matches(&object_identifier) {
+                        return false;
+                    }
+                }
 
+                // Then check per-rule ignore
+                let rule_name = diag.category.name().split('/').next_back().unwrap_or("");
                 if let Some(matcher) = rule_matchers.get(rule_name) {
-                    if let (Some(schema), Some(name)) =
-                        (&diag.advices.schema, &diag.advices.object_name)
-                    {
-                        let object_identifier = format!("{schema}.{name}");
-
-                        if matcher.matches(&object_identifier) {
-                            return false;
-                        }
+                    if matcher.matches(&object_identifier) {
+                        return false;
                     }
                 }
+
                 true
             });
         }