make it simpleeeer

Author: psteinroe

Cargo.toml

@@ -46,8 +46,8 @@ tree_sitter_sql          = { path = "./lib/tree_sitter_sql", version = "0.0.0" }
 unicode-width            = "0.1.12"
 
 # postgres specific crates
-pg_base_db                = { path = "./crates/pg_base_db", version = "0.0.0" }
 pg_analyse                = { path = "./crates/pg_analyse", version = "0.0.0" }
+pg_base_db                = { path = "./crates/pg_base_db", version = "0.0.0" }
 pg_cli                    = { path = "./crates/pg_cli", version = "0.0.0" }
 pg_commands               = { path = "./crates/pg_commands", version = "0.0.0" }
 pg_completions            = { path = "./crates/pg_completions", version = "0.0.0" }

crates/pg_analyse/Cargo.toml

@@ -13,18 +13,17 @@ version              = "0.0.0"
 
 
 [dependencies]
-pg_schema_cache.workspace                 = true
-pg_diagnostics.workspace                 = true
-pg_console.workspace                 = true
-pg_query_ext.workspace = true
-rustc-hash               = { workspace = true }
+pg_console.workspace      = true
+pg_diagnostics.workspace  = true
+pg_query_ext.workspace    = true
+pg_schema_cache.workspace = true
+rustc-hash                = { workspace = true }
 
-text-size.workspace = true
-enumflags2.workspace = true
-serde                    = { workspace = true, features = ["derive"], optional = true }
 biome_deserialize        = { workspace = true, optional = true }
 biome_deserialize_macros = { workspace = true, optional = true }
+enumflags2.workspace     = true
+serde                    = { workspace = true, features = ["derive"], optional = true }
+text-size.workspace      = true
 
 [features]
 serde = ["dep:serde", "dep:biome_deserialize", "dep:biome_deserialize_macros"]
-

crates/pg_analyse/src/categories.rs

@@ -332,7 +332,3 @@ impl RuleCategoriesBuilder {
         RuleCategories(self.flags)
     }
 }
-
-
-
-

crates/pg_analyse/src/context.rs

@@ -1,7 +1,10 @@
 use pg_diagnostics::{Error, Result};
 use std::path::Path;
 
-use crate::{categories::RuleCategory, rule::{GroupCategory, Rule, RuleGroup, RuleMetadata}};
+use crate::{
+    categories::RuleCategory,
+    rule::{GroupCategory, Rule, RuleGroup, RuleMetadata},
+};
 
 pub struct RuleContext<'a, R: Rule> {
     stmt: &'a pg_query_ext::NodeEnum,
@@ -15,7 +18,7 @@ where
 {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-    stmt: &'a pg_query_ext::NodeEnum,
+        stmt: &'a pg_query_ext::NodeEnum,
         file_path: &'a Path,
         options: &'a R::Options,
     ) -> Result<Self, Error> {
@@ -86,4 +89,3 @@ where
         self.file_path
     }
 }
-

crates/pg_analyse/src/diagnostics.rs

@@ -1,8 +1,18 @@
-use std::fmt::{Display, Formatter, Debug};
+use std::fmt::{Debug, Display, Formatter};
 
 use text_size::TextRange;
 
-use crate::{categories::RuleCategories, rule::{GroupCategory, Rule, RuleGroup}, RuleFilter};
+use crate::{
+    categories::RuleCategories,
+    rule::{GroupCategory, Rule, RuleGroup},
+};
+
+/// Allow filtering a single rule or group of rules by their names
+#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum RuleFilter<'a> {
+    Group(&'a str),
+    Rule(&'a str, &'a str),
+}
 
 /// Allows filtering the list of rules that will be executed in a run of the analyzer,
 /// and at what source code range signals (diagnostics or actions) may be raised
@@ -58,8 +68,6 @@ impl<'analysis> AnalysisFilter<'analysis> {
     }
 }
 
-
-
 impl<'a> RuleFilter<'a> {
     // Returns the group name of this filter.
     pub fn group(self) -> &'a str {
@@ -122,3 +130,64 @@ impl<'a> pg_console::fmt::Display for RuleFilter<'a> {
     }
 }
 
+/// Opaque identifier for a group of rule
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct GroupKey {
+    group: &'static str,
+}
+
+impl GroupKey {
+    pub(crate) fn new(group: &'static str) -> Self {
+        Self { group }
+    }
+
+    pub fn group<G: RuleGroup>() -> Self {
+        Self::new(G::NAME)
+    }
+}
+
+impl From<GroupKey> for RuleFilter<'static> {
+    fn from(key: GroupKey) -> Self {
+        RuleFilter::Group(key.group)
+    }
+}
+
+/// Opaque identifier for a single rule
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct RuleKey {
+    group: &'static str,
+    rule: &'static str,
+}
+
+impl RuleKey {
+    pub fn new(group: &'static str, rule: &'static str) -> Self {
+        Self { group, rule }
+    }
+
+    pub fn rule<R: Rule>() -> Self {
+        Self::new(<R::Group as RuleGroup>::NAME, R::METADATA.name)
+    }
+
+    pub fn group(&self) -> &'static str {
+        self.group
+    }
+
+    pub fn rule_name(&self) -> &'static str {
+        self.rule
+    }
+}
+
+impl From<RuleKey> for RuleFilter<'static> {
+    fn from(key: RuleKey) -> Self {
+        RuleFilter::Rule(key.group, key.rule)
+    }
+}
+
+impl PartialEq<RuleKey> for RuleFilter<'static> {
+    fn eq(&self, other: &RuleKey) -> bool {
+        match *self {
+            RuleFilter::Group(group) => group == other.group,
+            RuleFilter::Rule(group, rule) => group == other.group && rule == other.rule,
+        }
+    }
+}

crates/pg_analyse/src/filter.rs

@@ -1,34 +1,14 @@
 mod categories;
 mod context;
-mod diagnostics;
 mod filter;
-mod matcher;
 mod options;
 mod registry;
 mod rule;
-mod signals;
 
 pub use crate::categories::{
     ActionCategory, RefactorKind, RuleCategories, RuleCategoriesBuilder, RuleCategory,
     SourceActionKind, SUPPRESSION_ACTION_CATEGORY,
 };
-// pub use crate::diagnostics::{AnalyzerDiagnostic, RuleError, SuppressionDiagnostic};
-pub use crate::matcher::RuleKey;
 pub use crate::options::{AnalyzerConfiguration, AnalyzerOptions, AnalyzerRules};
-// pub use crate::query::{AddVisitor, QueryKey, QueryMatch, Queryable};
-pub use crate::registry::{
-    MetadataRegistry, RegistryVisitor,
-    RuleRegistry, RuleRegistryBuilder,
-};
-pub use crate::rule::{Rule};
-// pub use crate::rule::{
-//     GroupCategory, Rule, RuleAction, RuleDiagnostic, RuleGroup, RuleMeta, RuleMetadata, RuleSource,
-//     RuleSourceKind, SuppressAction,
-// };
-
-/// Allow filtering a single rule or group of rules by their names
-#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum RuleFilter<'a> {
-    Group(&'a str),
-    Rule(&'a str, &'a str),
-}
+pub use crate::registry::{MetadataRegistry, RegistryVisitor, RuleRegistry, RuleRegistryBuilder};
+pub use crate::rule::Rule;