Merge branch 'main' into refactor/lexer

Author: psteinroe

README.md

@@ -33,6 +33,21 @@ Our current focus is on refining and enhancing these core features while buildin
 - [psteinroe](https://github.com/psteinroe)
 - [juleswritescode](https://github.com/juleswritescode)
 
+## Development
+
+### Using Nix
+
+```bash
+nix develop
+docker-compose up -d
+```
+
+### Using Docker
+
+```bash
+docker-compose up -d
+```
+
 ## Acknowledgements
 
 A big thanks to the following projects, without which this project wouldn't have been possible:

crates/pgt_configuration/src/analyser/linter/rules.rs

@@ -121,6 +121,14 @@ impl Rules {
         }
         enabled_rules.difference(&disabled_rules).copied().collect()
     }
+    #[doc = r" It returns the disabled rules by configuration."]
+    pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+        let mut disabled_rules = FxHashSet::default();
+        if let Some(group) = self.safety.as_ref() {
+            disabled_rules.extend(&group.get_disabled_rules());
+        }
+        disabled_rules
+    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Eq, Merge, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]

crates/pgt_workspace/src/workspace/server/analyser.rs

@@ -68,14 +68,23 @@ impl<'a, 'b> LintVisitor<'a, 'b> {
 
     fn finish(mut self) -> (FxHashSet<RuleFilter<'a>>, FxHashSet<RuleFilter<'a>>) {
         let has_only_filter = !self.only.is_empty();
+
         if !has_only_filter {
             let enabled_rules = self
                 .settings
                 .as_linter_rules()
                 .map(|rules| rules.as_enabled_rules())
                 .unwrap_or_default();
             self.enabled_rules.extend(enabled_rules);
+
+            let disabled_rules = self
+                .settings
+                .as_linter_rules()
+                .map(|rules| rules.as_disabled_rules())
+                .unwrap_or_default();
+            self.disabled_rules.extend(disabled_rules);
         }
+
         (self.enabled_rules, self.disabled_rules)
     }
 
@@ -127,3 +136,42 @@ impl RegistryVisitor for LintVisitor<'_, '_> {
         self.push_rule::<R>()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use pgt_analyse::RuleFilter;
+    use pgt_configuration::{RuleConfiguration, Rules, analyser::Safety};
+
+    use crate::{
+        settings::{LinterSettings, Settings},
+        workspace::server::analyser::AnalyserVisitorBuilder,
+    };
+
+    #[test]
+    fn recognizes_disabled_rules() {
+        let settings = Settings {
+            linter: LinterSettings {
+                rules: Some(Rules {
+                    safety: Some(Safety {
+                        ban_drop_column: Some(RuleConfiguration::Plain(
+                            pgt_configuration::RulePlainConfiguration::Off,
+                        )),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let (_, disabled_rules) = AnalyserVisitorBuilder::new(&settings)
+            .with_linter_rules(&[], &[])
+            .finish();
+
+        assert_eq!(
+            disabled_rules,
+            vec![RuleFilter::Rule("safety", "banDropColumn")]
+        )
+    }
+}

flake.lock

@@ -0,0 +1,92 @@
+{
+  description = "PostgreSQL Language Server Development Environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs = { self, nixpkgs, flake-utils, rust-overlay }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        overlays = [ (import rust-overlay) ];
+        pkgs = import nixpkgs {
+          inherit system overlays;
+        };
+
+        # Read rust-toolchain.toml to get the exact Rust version
+        rustToolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+
+        # Development dependencies
+        buildInputs = with pkgs; [
+          # Rust toolchain
+          rustToolchain
+          
+          # Node.js ecosystem
+          bun
+          nodejs_20
+          
+          # Python for additional tooling
+          python3
+          python3Packages.pip
+          
+          # System dependencies
+          pkg-config
+          openssl
+          
+          # Build tools
+          just
+          git
+          
+          # LSP and development tools
+          rust-analyzer
+          
+          # Additional tools that might be needed
+          cmake
+          gcc
+          libiconv
+        ];
+        
+        # Environment variables
+        env = {
+          RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
+          PKG_CONFIG_PATH = "${pkgs.openssl.dev}/lib/pkgconfig";
+        };
+
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          inherit buildInputs;
+          
+          shellHook = ''
+            echo "PostgreSQL Language Server Development Environment"
+            echo "Available tools:"
+            echo "  • Rust $(rustc --version)"
+            echo "  • Node.js $(node --version)"
+            echo "  • Bun $(bun --version)"
+            echo "  • Just $(just --version)"
+            echo ""
+            echo "Development Commands:"
+            echo "  • just --list   # Show tasks"
+            echo "  • cargo check   # Check Rust"
+            echo "  • bun install   # Install deps"
+            echo ""
+            echo "Use Docker for database:"
+            echo "  • docker-compose up -d"
+            echo ""
+            
+            # Set environment variables
+            ${pkgs.lib.concatStringsSep "\n" 
+              (pkgs.lib.mapAttrsToList (name: value: "export ${name}=\"${value}\"") env)}
+          '';
+        };
+
+        # Formatter for nix files
+        formatter = pkgs.nixfmt-rfc-style;
+      }
+    );
+}

flake.nix

@@ -61,6 +61,8 @@ fn generate_for_groups(
     let mut group_idents = Vec::with_capacity(groups.len());
     let mut group_strings = Vec::with_capacity(groups.len());
     let mut group_as_default_rules = Vec::with_capacity(groups.len());
+    let mut group_as_disabled_rules = Vec::with_capacity(groups.len());
+
     for (group, rules) in groups {
         let group_pascal_ident = quote::format_ident!("{}", &Case::Pascal.convert(group));
         let group_ident = quote::format_ident!("{}", group);
@@ -95,6 +97,12 @@ fn generate_for_groups(
             }
         });
 
+        group_as_disabled_rules.push(quote! {
+            if let Some(group) = self.#group_ident.as_ref() {
+                disabled_rules.extend(&group.get_disabled_rules());
+            }
+        });
+
         group_pascal_idents.push(group_pascal_ident);
         group_idents.push(group_ident);
         group_strings.push(Literal::string(group));
@@ -246,6 +254,13 @@ fn generate_for_groups(
                     #( #group_as_default_rules )*
                     enabled_rules
                 }
+
+                /// It returns the disabled rules by configuration.
+                pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+                    let mut disabled_rules = FxHashSet::default();
+                    #( #group_as_disabled_rules )*
+                    disabled_rules
+                }
             }
 
             #( #struct_groups )*
@@ -358,6 +373,13 @@ fn generate_for_groups(
 
                     enabled_rules.difference(&disabled_rules).copied().collect()
                 }
+
+                /// It returns the disabled rules by configuration.
+                pub fn as_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
+                    let mut disabled_rules = FxHashSet::default();
+                    #( #group_as_disabled_rules )*
+                    disabled_rules
+                }
             }
 
             #( #struct_groups )*