squawk-cli 2.28.0__tar.gz → 2.29.0__tar.gz

{squawk_cli-2.28.0 → squawk_cli-2.29.0}/Cargo.lock

@@ -1831,7 +1831,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -1860,7 +1860,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-github"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -1869,16 +1869,28 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "squawk-ide"
+version = "2.29.0"
+dependencies = [
+ "annotate-snippets",
+ "insta",
+ "line-index",
+ "log",
+ "rowan",
+ "squawk-syntax",
+]
+
 [[package]]
 name = "squawk-lexer"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-linter"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "enum-iterator",
  "insta",
@@ -1892,7 +1904,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "camino",
  "dir-test",
@@ -1905,7 +1917,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "anyhow",
  "insta",
@@ -1913,9 +1925,11 @@ dependencies = [
  "log",
  "lsp-server",
  "lsp-types",
+ "rowan",
  "serde",
  "serde_json",
  "simplelog",
+ "squawk-ide",
  "squawk-lexer",
  "squawk-linter",
  "squawk-syntax",
@@ -1923,7 +1937,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "camino",
  "dir-test",
@@ -1935,7 +1949,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -2752,7 +2766,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "anyhow",
  "camino",

{squawk_cli-2.28.0 → squawk_cli-2.29.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.28.0"
+version = "2.29.0"
 edition = "2024"
 rust-version = "1.90.0"
 authors = ["Squawk Team & Contributors"]
@@ -59,12 +59,13 @@ snapbox = { version = "0.6.0", features = ["diff", "term-svg", "cmd"] }
 
 # local
 # we have to make the versions explicit otherwise `cargo publish` won't work
-squawk-github = { path = "./crates/squawk_github", version = "2.27.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.27.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.27.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.27.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.27.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.27.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.29.0" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.29.0" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.29.0" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.29.0" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.29.0" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.29.0" }
+squawk-server = { path = "./crates/squawk_server", version = "2.29.0" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.28.0 → squawk_cli-2.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.28.0
+Version: 2.29.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS

squawk_cli-2.29.0/crates/squawk/src/cmd.rs

@@ -0,0 +1,87 @@
+use std::{path::PathBuf, process};
+
+use crate::{
+    Command, config::Config, debug::DebugArgs, file_finding::find_paths, reporter::LintArgs,
+};
+
+pub(crate) struct Stdin {
+    pub(crate) path: Option<String>,
+}
+
+pub(crate) enum Input {
+    Stdin(Stdin),
+    Paths(Vec<PathBuf>),
+}
+
+pub(crate) enum Cmd {
+    Debug(DebugArgs),
+    Lint(LintArgs),
+    Help,
+    None,
+    Server,
+    UploadToGithub(Box<Config>),
+}
+
+impl Cmd {
+    fn resolve_cli(conf: Config) -> Cmd {
+        // TODO: do we need to do the same thing for the github command?
+        let found_paths =
+            find_paths(&conf.path_patterns, &conf.excluded_paths).unwrap_or_else(|e| {
+                eprintln!("Failed to find files: {e}");
+                process::exit(1);
+            });
+        if found_paths.is_empty() && !conf.path_patterns.is_empty() {
+            eprintln!(
+                "Failed to find files for provided patterns: {:?}",
+                conf.path_patterns
+            );
+            if !conf.no_error_on_unmatched_pattern {
+                process::exit(1);
+            }
+        }
+        if !found_paths.is_empty() || conf.is_stdin {
+            let read_stdin = found_paths.is_empty() && conf.is_stdin;
+            let input = if read_stdin {
+                Input::Stdin(Stdin {
+                    path: conf.stdin_filepath,
+                })
+            } else {
+                Input::Paths(found_paths)
+            };
+            if let Some(debug_option) = conf.debug {
+                return Cmd::Debug(DebugArgs {
+                    input,
+                    debug_option,
+                    verbose: conf.verbose,
+                });
+            } else {
+                return Cmd::Lint(LintArgs {
+                    input,
+                    excluded_rules: conf.excluded_rules,
+                    pg_version: conf.pg_version,
+                    assume_in_transaction: conf.assume_in_transaction,
+                    reporter: conf.reporter,
+                    github_annotations: conf.github_annotations,
+                });
+            }
+        } else if !conf.no_error_on_unmatched_pattern {
+            return Cmd::Help;
+        } else {
+            return Cmd::None;
+        }
+    }
+
+    pub(crate) fn from(opts: crate::Opts) -> Cmd {
+        match opts.cmd {
+            Some(Command::Server) => Cmd::Server,
+            Some(Command::UploadToGithub(_)) => {
+                let conf = Config::from(opts);
+                Cmd::UploadToGithub(Box::new(conf))
+            }
+            None => {
+                let conf = Config::from(opts);
+                Cmd::resolve_cli(conf)
+            }
+        }
+    }
+}

squawk_cli-2.29.0/crates/squawk/src/config.rs

@@ -0,0 +1,258 @@
+use anyhow::{Context, Result};
+use log::info;
+use serde::Deserialize;
+use squawk_linter::{Rule, Version};
+use std::{
+    env,
+    io::{self, IsTerminal},
+    path::{Path, PathBuf},
+    process,
+};
+
+use crate::{Command, DebugOption, Opts, Reporter, UploadToGithubArgs};
+
+const FILE_NAME: &str = ".squawk.toml";
+
+#[derive(Debug, Default, Deserialize)]
+pub struct UploadToGitHubConfig {
+    #[serde(default)]
+    pub fail_on_violations: Option<bool>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+pub struct ConfigFile {
+    #[serde(default)]
+    pub excluded_paths: Vec<String>,
+    #[serde(default)]
+    pub excluded_rules: Vec<Rule>,
+    #[serde(default)]
+    pub pg_version: Option<Version>,
+    #[serde(default)]
+    pub assume_in_transaction: Option<bool>,
+    #[serde(default)]
+    pub upload_to_github: UploadToGitHubConfig,
+}
+
+impl ConfigFile {
+    pub fn parse(custom_path: Option<PathBuf>) -> Result<Option<Self>> {
+        let path = if let Some(path) = custom_path {
+            Some(path)
+        } else {
+            find_by_traversing_back()?
+        };
+
+        if let Some(p) = path {
+            info!("using config file path: {}", p.display());
+
+            let file_content = std::fs::read_to_string(p)?;
+            return Ok(Some(toml::from_str(&file_content)?));
+        }
+
+        info!("no config file found");
+        Ok(None)
+    }
+}
+
+pub struct Config {
+    pub excluded_paths: Vec<String>,
+    pub excluded_rules: Vec<Rule>,
+    pub pg_version: Option<Version>,
+    pub assume_in_transaction: bool,
+    pub upload_to_github: UploadToGitHubConfig,
+    pub upload_to_github_args: Option<UploadToGithubArgs>,
+    pub no_error_on_unmatched_pattern: bool,
+    pub is_stdin: bool,
+    pub stdin_filepath: Option<String>,
+    pub github_annotations: bool,
+    pub reporter: Reporter,
+    pub verbose: bool,
+    pub debug: Option<DebugOption>,
+    pub path_patterns: Vec<String>,
+}
+
+impl Config {
+    pub fn from(opts: Opts) -> Config {
+        let conf = ConfigFile::parse(opts.config_path)
+            .unwrap_or_else(|e| {
+                eprintln!("Configuration error: {e}");
+                process::exit(1);
+            })
+            .unwrap_or_default();
+
+        // the --exclude flag completely overrides the configuration file.
+        let excluded_rules = if let Some(excluded_rules) = opts.excluded_rules {
+            excluded_rules
+        } else {
+            conf.excluded_rules.clone()
+        };
+
+        // the --exclude-path flag completely overrides the configuration file.
+        let excluded_paths = if let Some(excluded_paths) = opts.excluded_path {
+            excluded_paths
+        } else {
+            conf.excluded_paths.clone()
+        };
+        let pg_version = if let Some(pg_version) = opts.pg_version {
+            Some(pg_version)
+        } else {
+            conf.pg_version
+        };
+
+        let assume_in_transaction = if opts.assume_in_transaction {
+            opts.assume_in_transaction
+        } else if opts.no_assume_in_transaction {
+            !opts.no_assume_in_transaction
+        } else {
+            conf.assume_in_transaction.unwrap_or_default()
+        };
+
+        let no_error_on_unmatched_pattern = if opts.no_error_on_unmatched_pattern {
+            opts.no_error_on_unmatched_pattern
+        } else {
+            // TODO: we should have config support for these
+            false
+        };
+
+        info!("pg version: {pg_version:?}");
+        info!("excluded rules: {:?}", &excluded_rules);
+        info!("excluded paths: {:?}", &excluded_paths);
+        info!("assume in a transaction: {assume_in_transaction:?}");
+        info!("no error on unmatched pattern: {no_error_on_unmatched_pattern:?}");
+
+        let is_stdin = !io::stdin().is_terminal();
+        let github_annotations = std::env::var("GITHUB_ACTIONS").is_ok()
+            && std::env::var("SQUAWK_DISABLE_GITHUB_ANNOTATIONS").is_err();
+
+        // TODO: we should support all of these in the config file as well
+        let debug = opts.debug;
+        let verbose = opts.verbose;
+        let path_patterns = opts.path_patterns;
+        let reporter = opts.reporter.unwrap_or_default();
+        let stdin_filepath = opts.stdin_filepath;
+        let upload_to_github = conf.upload_to_github;
+        let upload_to_github_args = match opts.cmd {
+            Some(Command::UploadToGithub(args)) => Some(*args),
+            _ => None,
+        };
+
+        Config {
+            excluded_paths,
+            excluded_rules,
+            pg_version,
+            assume_in_transaction,
+            upload_to_github,
+            upload_to_github_args,
+            no_error_on_unmatched_pattern,
+            is_stdin,
+            stdin_filepath,
+            github_annotations,
+            reporter,
+            verbose,
+            debug,
+            path_patterns,
+        }
+    }
+}
+
+fn recurse_directory(directory: &Path, file_name: &str) -> Result<Option<PathBuf>, std::io::Error> {
+    for entry in directory.read_dir()? {
+        let entry = entry?;
+        if entry.file_name() == file_name {
+            return Ok(Some(entry.path()));
+        }
+    }
+    if let Some(parent) = directory.parent() {
+        recurse_directory(parent, file_name)
+    } else {
+        Ok(None)
+    }
+}
+
+fn find_by_traversing_back() -> Result<Option<PathBuf>> {
+    recurse_directory(&env::current_dir()?, FILE_NAME)
+        .context("Error when finding configuration file")
+}
+
+#[cfg(test)]
+mod test_config {
+    use std::fs;
+    use tempfile::NamedTempFile;
+
+    use insta::assert_debug_snapshot;
+
+    use super::*;
+
+    #[test]
+    fn load_cfg_full() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r#"
+pg_version = "19.1"
+excluded_paths = ["example.sql"]
+excluded_rules = ["require-concurrent-index-creation"]
+assume_in_transaction = true
+        
+        "#;
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_pg_version() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r#"
+pg_version = "19.1"
+        
+        "#;
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_excluded_rules() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r#"
+excluded_rules = ["require-concurrent-index-creation"]
+        
+        "#;
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_excluded_paths() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r#"
+excluded_paths = ["example.sql"]
+        
+        "#;
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_assume_in_transaction() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r"
+assume_in_transaction = false
+        
+        ";
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_fail_on_violations() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r"
+[upload_to_github]
+fail_on_violations = true        
+        ";
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+    #[test]
+    fn load_excluded_rules_with_alias() {
+        let squawk_toml = NamedTempFile::new().expect("generate tempFile");
+        let file = r#"
+excluded_rules = ["prefer-timestamp-tz", "prefer-timestamptz"]
+
+        "#;
+        fs::write(&squawk_toml, file).expect("Unable to write file");
+        assert_debug_snapshot!(ConfigFile::parse(Some(squawk_toml.path().to_path_buf())));
+    }
+}

{squawk_cli-2.28.0 → squawk_cli-2.29.0}/crates/squawk/src/debug.rs

@@ -1,4 +1,4 @@
-use std::{io, path::PathBuf};
+use std::io;
 
 use annotate_snippets::{AnnotationKind, Level, Renderer, Snippet, renderer::DecorStyle};
 use anyhow::Result;
@@ -7,23 +7,24 @@ use squawk_syntax::{ast::AstNode, syntax_error::SyntaxError};
 
 use crate::{
     DebugOption,
+    cmd::Input,
     file::{sql_from_path, sql_from_stdin},
 };
 
-pub(crate) fn debug<W: io::Write>(
-    f: &mut W,
-    paths: &[PathBuf],
-    read_stdin: bool,
-    debug_option: &DebugOption,
-    verbose: bool,
-) -> Result<()> {
+pub(crate) struct DebugArgs {
+    pub(crate) input: Input,
+    pub(crate) debug_option: DebugOption,
+    pub(crate) verbose: bool,
+}
+
+pub(crate) fn debug<W: io::Write>(f: &mut W, args: DebugArgs) -> Result<()> {
     let process_dump_ast = |sql: &str, filename: &str, f: &mut W| -> Result<()> {
-        match debug_option {
+        match args.debug_option {
             DebugOption::Lex => {
                 let tokens = squawk_lexer::tokenize(sql);
                 let mut start = 0;
                 for token in tokens {
-                    if verbose {
+                    if args.verbose {
                         let content = &sql[start as usize..(start + token.len) as usize];
                         start += token.len;
                         writeln!(f, "{content:?} @ {:?}", token.kind)?;
@@ -34,7 +35,7 @@ pub(crate) fn debug<W: io::Write>(
             }
             DebugOption::Parse => {
                 let parse = squawk_syntax::SourceFile::parse(sql);
-                if verbose {
+                if args.verbose {
                     writeln!(f, "{}\n---", parse.syntax_node())?;
                 }
                 writeln!(f, "{:#?}", parse.syntax_node())?;
@@ -65,16 +66,20 @@ pub(crate) fn debug<W: io::Write>(
         }
         Ok(())
     };
-    if read_stdin {
-        let sql = sql_from_stdin()?;
-        process_dump_ast(&sql, "stdin", f)?;
-        return Ok(());
-    }
 
-    for path in paths {
-        let sql = sql_from_path(path)?;
-        process_dump_ast(&sql, &path.to_string_lossy(), f)?;
-    }
+    match args.input {
+        Input::Stdin(_) => {
+            let sql = sql_from_stdin()?;
+            process_dump_ast(&sql, "stdin", f)?;
+        }
+        Input::Paths(path_bufs) => {
+            for path in path_bufs {
+                let sql = sql_from_path(&path)?;
+                process_dump_ast(&sql, &path.to_string_lossy(), f)?;
+            }
+        }
+    };
+
     Ok(())
 }
 

{squawk_cli-2.28.0 → squawk_cli-2.29.0}/crates/squawk/src/github.rs

@@ -1,12 +1,12 @@
-use crate::UploadToGithubArgs;
+use crate::cmd::Input;
 use crate::config::Config;
 use crate::reporter::{CheckReport, fmt_github_annotations, fmt_tty_violation};
-use crate::{file_finding::find_paths, reporter::check_files};
-use anyhow::{Result, anyhow, bail};
+use crate::{LintArgs, UploadToGithubArgs};
+use crate::{file_finding::find_paths, reporter::lint_files};
+use anyhow::{Context, Result, anyhow, bail};
 use console::strip_ansi_codes;
 use log::info;
 use squawk_github::{GitHubApi, actions, app, comment_on_pr};
-use squawk_linter::{Rule, Version};
 use std::io;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -38,19 +38,21 @@ fn get_github_private_key(
 }
 
 fn create_gh_app(
-    github_api_url: Option<String>,
-    github_install_id: Option<i64>,
-    github_app_id: Option<i64>,
-    github_token: Option<String>,
-    github_private_key: Option<String>,
-    github_private_key_base64: Option<String>,
+    github_api_url: &Option<String>,
+    github_install_id: &Option<i64>,
+    github_app_id: &Option<i64>,
+    github_token: &Option<String>,
+    github_private_key: &Option<String>,
+    github_private_key_base64: &Option<String>,
 ) -> Result<Box<dyn GitHubApi>> {
     if let Some(github_install_id) = github_install_id {
         if let Some(github_app_id) = github_app_id {
             info!("using github app client");
-            let gh_private_key =
-                get_github_private_key(github_private_key, github_private_key_base64)?;
-            let app = app::GitHub::new(&gh_private_key, github_app_id, github_install_id)?;
+            let gh_private_key = get_github_private_key(
+                github_private_key.clone(),
+                github_private_key_base64.clone(),
+            )?;
+            let app = app::GitHub::new(&gh_private_key, *github_app_id, *github_install_id)?;
             return Ok(Box::new(app));
         }
     }
@@ -58,8 +60,8 @@ fn create_gh_app(
     if let Some(github_token) = github_token {
         info!("using github actions client");
         let client = match github_api_url {
-            Some(github_api_url) => actions::GitHub::new_with_url(&github_api_url, &github_token),
-            None => actions::GitHub::new(&github_token),
+            Some(github_api_url) => actions::GitHub::new_with_url(github_api_url, github_token),
+            None => actions::GitHub::new(github_token),
         };
         return Ok(Box::new(client));
     };
@@ -79,17 +81,10 @@ fn create_gh_app(
 
 const COMMENT_HEADER: &str = "# Squawk Report";
 
-pub fn check_and_comment_on_pr(
-    args: UploadToGithubArgs,
-    cfg: &Config,
-    is_stdin: bool,
-    stdin_path: Option<String>,
-    exclude: &[Rule],
-    exclude_paths: &[String],
-    pg_version: Option<Version>,
-    assume_in_transaction: bool,
-    github_annotations: bool,
-) -> Result<()> {
+pub fn check_and_comment_on_pr(cfg: Config) -> Result<()> {
+    let args = cfg
+        .upload_to_github_args
+        .context("Should always have args for the github command")?;
     let UploadToGithubArgs {
         paths,
         fail_on_violations,
@@ -112,25 +107,25 @@ pub fn check_and_comment_on_pr(
         };
 
     let github_app = create_gh_app(
-        github_api_url,
-        github_install_id,
-        github_app_id,
-        github_token,
-        github_private_key,
-        github_private_key_base64,
+        &github_api_url,
+        &github_install_id,
+        &github_app_id,
+        &github_token,
+        &github_private_key,
+        &github_private_key_base64,
     )?;
 
-    let found_paths = find_paths(&paths, exclude_paths)?;
+    let found_paths = find_paths(&paths, &cfg.excluded_paths)?;
 
     info!("checking files");
-    let file_results = check_files(
-        &found_paths,
-        is_stdin,
-        stdin_path,
-        exclude,
-        pg_version,
-        assume_in_transaction,
-    )?;
+    let file_results = lint_files(&LintArgs {
+        input: Input::Paths(found_paths),
+        excluded_rules: cfg.excluded_rules,
+        pg_version: cfg.pg_version,
+        assume_in_transaction: cfg.assume_in_transaction,
+        reporter: cfg.reporter,
+        github_annotations: cfg.github_annotations,
+    })?;
 
     // We should only leave a comment when there are files checked.
     if paths.is_empty() {
@@ -149,7 +144,7 @@ pub fn check_and_comment_on_pr(
         COMMENT_HEADER,
     )?;
 
-    if github_annotations {
+    if cfg.github_annotations {
         let stdout = io::stdout();
         let mut handle = stdout.lock();
         fmt_github_annotations(&mut handle, &file_results)?;