progress

Author: psteinroe

crates/pgt_cli/src/commands/check.rs

@@ -1,76 +1,141 @@
 use crate::cli_options::CliOptions;
-use crate::{CliDiagnostic, Execution, TraversalMode};
-use biome_deserialize::Merge;
+use crate::commands::get_files_to_process_with_cli_options;
+use crate::execute::{StdinPayload, run_files, run_stdin};
+use crate::reporter::Report;
+use crate::{CliDiagnostic, CliSession, VcsIntegration};
+use crate::{ExecutionConfig, ExecutionMode, VcsTargeting};
 use pgt_configuration::PartialConfiguration;
 use pgt_console::Console;
+use pgt_diagnostics::category;
 use pgt_fs::FileSystem;
-use pgt_workspace::{DynRef, Workspace, WorkspaceError, configuration::LoadedConfiguration};
+use pgt_workspace::DynRef;
 use std::ffi::OsString;
 
-use super::{CommandRunner, get_files_to_process_with_cli_options};
+#[allow(dead_code)]
+pub struct CheckArgs {
+    pub configuration: Option<PartialConfiguration>,
+    pub paths: Vec<OsString>,
+    pub stdin_file_path: Option<String>,
+    pub staged: bool,
+    pub changed: bool,
+    pub since: Option<String>,
+    pub apply: bool,
+    pub apply_unsafe: bool,
+}
+
+pub fn check(
+    mut session: CliSession,
+    cli_options: &CliOptions,
+    args: CheckArgs,
+) -> Result<(), CliDiagnostic> {
+    validate_args(&args)?;
+
+    let configuration = session.prepare_with_config(cli_options, args.configuration.clone())?;
+    session.setup_workspace(configuration.clone(), VcsIntegration::Enabled)?;
+
+    let paths = resolve_paths(session.fs(), &configuration, &args)?;
+
+    let vcs = VcsTargeting {
+        staged: args.staged,
+        changed: args.changed,
+    };
+
+    let max_diagnostics = if cli_options.reporter.is_default() {
+        cli_options.max_diagnostics.into()
+    } else {
+        u32::MAX
+    };
+
+    let mode = ExecutionMode::Check { vcs };
+    let execution = ExecutionConfig::new(mode, max_diagnostics);
 
-pub(crate) struct CheckCommandPayload {
-    pub(crate) configuration: Option<PartialConfiguration>,
-    pub(crate) paths: Vec<OsString>,
-    pub(crate) stdin_file_path: Option<String>,
-    pub(crate) staged: bool,
-    pub(crate) changed: bool,
-    pub(crate) since: Option<String>,
+    if let Some(stdin_path) = args.stdin_file_path.as_deref() {
+        let payload = read_stdin_payload(stdin_path, session.console())?;
+        run_stdin(&mut session, &execution, payload)
+    } else {
+        let report: Report = run_files(&mut session, &execution, paths)?;
+
+        let exit_result = enforce_exit_codes(cli_options, &report);
+        session.report("check", cli_options, &report)?;
+        exit_result
+    }
 }
 
-impl CommandRunner for CheckCommandPayload {
-    const COMMAND_NAME: &'static str = "check";
-
-    fn merge_configuration(
-        &mut self,
-        loaded_configuration: LoadedConfiguration,
-        _fs: &DynRef<'_, dyn FileSystem>,
-        _console: &mut dyn Console,
-    ) -> Result<PartialConfiguration, WorkspaceError> {
-        let LoadedConfiguration {
-            configuration: mut fs_configuration,
-            ..
-        } = loaded_configuration;
-
-        if let Some(configuration) = self.configuration.clone() {
-            // overwrite fs config with cli args
-            fs_configuration.merge_with(configuration);
+fn resolve_paths(
+    fs: &DynRef<'_, dyn FileSystem>,
+    configuration: &PartialConfiguration,
+    args: &CheckArgs,
+) -> Result<Vec<OsString>, CliDiagnostic> {
+    let mut paths = get_files_to_process_with_cli_options(
+        args.since.as_deref(),
+        args.changed,
+        args.staged,
+        fs,
+        configuration,
+    )?
+    .unwrap_or_else(|| args.paths.clone());
+
+    if paths.is_empty() && args.stdin_file_path.is_none() {
+        if let Some(current_dir) = fs.working_directory() {
+            paths.push(current_dir.into_os_string());
         }
+    }
 
-        Ok(fs_configuration)
+    Ok(paths)
+}
+
+fn read_stdin_payload(
+    path: &str,
+    console: &mut dyn Console,
+) -> Result<StdinPayload, CliDiagnostic> {
+    let input_code = console.read();
+    if let Some(input_code) = input_code {
+        Ok(StdinPayload {
+            path: path.into(),
+            content: input_code,
+        })
+    } else {
+        Err(CliDiagnostic::missing_argument("stdin", "check"))
     }
+}
+
+fn enforce_exit_codes(cli_options: &CliOptions, payload: &Report) -> Result<(), CliDiagnostic> {
+    let traversal = payload.traversal.as_ref();
+    let processed = traversal.map_or(0, |t| t.changed + t.unchanged);
+    let skipped = traversal.map_or(0, |t| t.skipped);
 
-    fn get_files_to_process(
-        &self,
-        fs: &DynRef<'_, dyn FileSystem>,
-        configuration: &PartialConfiguration,
-    ) -> Result<Vec<OsString>, CliDiagnostic> {
-        let paths = get_files_to_process_with_cli_options(
-            self.since.as_deref(),
-            self.changed,
-            self.staged,
-            fs,
-            configuration,
-        )?
-        .unwrap_or(self.paths.clone());
-
-        Ok(paths)
+    if processed.saturating_sub(skipped) == 0 && !cli_options.no_errors_on_unmatched {
+        return Err(CliDiagnostic::no_files_processed());
     }
 
-    fn get_stdin_file_path(&self) -> Option<&str> {
-        self.stdin_file_path.as_deref()
+    let warnings = payload.warnings;
+    let errors = payload.errors;
+    let category = category!("check");
+
+    if errors > 0 {
+        return Err(CliDiagnostic::check_error(category));
     }
 
-    fn get_execution(
-        &self,
-        cli_options: &CliOptions,
-        console: &mut dyn Console,
-        _workspace: &dyn Workspace,
-    ) -> Result<Execution, CliDiagnostic> {
-        Ok(Execution::new(TraversalMode::Check {
-            stdin: self.get_stdin(console)?,
-            vcs_targeted: (self.staged, self.changed).into(),
-        })
-        .set_report(cli_options))
+    if warnings > 0 && cli_options.error_on_warnings {
+        return Err(CliDiagnostic::check_warnings(category));
     }
+
+    Ok(())
+}
+
+fn validate_args(args: &CheckArgs) -> Result<(), CliDiagnostic> {
+    if args.since.is_some() {
+        if !args.changed {
+            return Err(CliDiagnostic::incompatible_arguments("since", "changed"));
+        }
+        if args.staged {
+            return Err(CliDiagnostic::incompatible_arguments("since", "staged"));
+        }
+    }
+
+    if args.changed && args.staged {
+        return Err(CliDiagnostic::incompatible_arguments("changed", "staged"));
+    }
+
+    Ok(())
 }

crates/pgt_cli/src/commands/dblint.rs

@@ -0,0 +1,18 @@
+use crate::cli_options::CliOptions;
+use crate::reporter::Report;
+use crate::{CliDiagnostic, CliSession, VcsIntegration};
+use pgt_configuration::PartialConfiguration;
+
+pub fn dblint(
+    mut session: CliSession,
+    cli_options: &CliOptions,
+    cli_configuration: Option<PartialConfiguration>,
+) -> Result<(), CliDiagnostic> {
+    let configuration = session.prepare_with_config(cli_options, cli_configuration)?;
+    session.setup_workspace(configuration, VcsIntegration::Disabled)?;
+
+    // TODO: Implement actual dblint logic here
+    let report = Report::new(vec![], std::time::Duration::new(0, 0), 0, None);
+
+    session.report("dblint", cli_options, &report)
+}

crates/pgt_cli/src/commands/mod.rs

@@ -1,23 +1,17 @@
 use crate::changed::{get_changed_files, get_staged_files};
 use crate::cli_options::{CliOptions, CliReporter, ColorsArg, cli_options};
-use crate::execute::Stdin;
 use crate::logging::LoggingKind;
-use crate::{
-    CliDiagnostic, CliSession, Execution, LoggingLevel, VERSION, execute_mode, setup_cli_subscriber,
-};
+use crate::{CliDiagnostic, LoggingLevel, VERSION};
 use bpaf::Bpaf;
 use pgt_configuration::{PartialConfiguration, partial_configuration};
-use pgt_console::{Console, ConsoleExt, markup};
-use pgt_fs::{ConfigName, FileSystem};
-use pgt_workspace::PartialConfigurationExt;
-use pgt_workspace::configuration::{LoadedConfiguration, load_configuration};
-use pgt_workspace::workspace::{RegisterProjectFolderParams, UpdateSettingsParams};
-use pgt_workspace::{DynRef, Workspace, WorkspaceError};
+use pgt_fs::FileSystem;
+use pgt_workspace::DynRef;
 use std::ffi::OsString;
 use std::path::PathBuf;
 pub(crate) mod check;
 pub(crate) mod clean;
 pub(crate) mod daemon;
+pub(crate) mod dblint;
 pub(crate) mod init;
 pub(crate) mod version;
 
@@ -286,145 +280,7 @@ impl PgtCommand {
     }
 }
 
-/// Generic interface for executing commands.
-///
-/// Consumers must implement the following methods:
-///
-/// - [CommandRunner::merge_configuration]
-/// - [CommandRunner::get_files_to_process]
-/// - [CommandRunner::get_stdin_file_path]
-/// - [CommandRunner::should_write]
-/// - [CommandRunner::get_execution]
-///
-/// Optional methods:
-/// - [CommandRunner::check_incompatible_arguments]
-pub(crate) trait CommandRunner: Sized {
-    const COMMAND_NAME: &'static str;
-
-    /// The main command to use.
-    fn run(&mut self, session: CliSession, cli_options: &CliOptions) -> Result<(), CliDiagnostic> {
-        setup_cli_subscriber(cli_options.log_level, cli_options.log_kind);
-        let fs = &session.app.fs;
-        let console = &mut *session.app.console;
-        let workspace = &*session.app.workspace;
-        self.check_incompatible_arguments()?;
-        let (execution, paths) = self.configure_workspace(fs, console, workspace, cli_options)?;
-        execute_mode(execution, session, cli_options, paths)
-    }
-
-    /// This function prepares the workspace with the following:
-    /// - Loading the configuration file.
-    /// - Configure the VCS integration
-    /// - Computes the paths to traverse/handle. This changes based on the VCS arguments that were passed.
-    /// - Register a project folder using the working directory.
-    /// - Updates the settings that belong to the project registered
-    fn configure_workspace(
-        &mut self,
-        fs: &DynRef<'_, dyn FileSystem>,
-        console: &mut dyn Console,
-        workspace: &dyn Workspace,
-        cli_options: &CliOptions,
-    ) -> Result<(Execution, Vec<OsString>), CliDiagnostic> {
-        let loaded_configuration =
-            load_configuration(fs, cli_options.as_configuration_path_hint())?;
-
-        // Check for deprecated config filename
-        if let Some(config_path) = &loaded_configuration.file_path {
-            if let Some(file_name) = config_path.file_name().and_then(|n| n.to_str()) {
-                if ConfigName::is_deprecated(file_name) {
-                    console.log(markup! {
-                        <Warn>"Warning: "</Warn>"You are using the deprecated config filename '"<Emphasis>"postgrestools.jsonc"</Emphasis>"'. \
-                        Please rename it to '"<Emphasis>"postgres-language-server.jsonc"</Emphasis>"'. \
-                        Support for the old filename will be removed in a future version.\n"
-                    });
-                }
-            }
-        }
-
-        let configuration_path = loaded_configuration.directory_path.clone();
-        let configuration = self.merge_configuration(loaded_configuration, fs, console)?;
-        let vcs_base_path = configuration_path.or(fs.working_directory());
-        let (vcs_base_path, gitignore_matches) =
-            configuration.retrieve_gitignore_matches(fs, vcs_base_path.as_deref())?;
-        let paths = self.get_files_to_process(fs, &configuration)?;
-        workspace.register_project_folder(RegisterProjectFolderParams {
-            path: fs.working_directory(),
-            set_as_current_workspace: true,
-        })?;
-
-        workspace.update_settings(UpdateSettingsParams {
-            workspace_directory: fs.working_directory(),
-            configuration,
-            vcs_base_path,
-            gitignore_matches,
-        })?;
-
-        let execution = self.get_execution(cli_options, console, workspace)?;
-        Ok((execution, paths))
-    }
-
-    /// Computes [Stdin] if the CLI has the necessary information.
-    ///
-    /// ## Errors
-    /// - If the user didn't provide anything via `stdin` but the option `--stdin-file-path` is passed.
-    fn get_stdin(&self, console: &mut dyn Console) -> Result<Option<Stdin>, CliDiagnostic> {
-        let stdin = if let Some(stdin_file_path) = self.get_stdin_file_path() {
-            let input_code = console.read();
-            if let Some(input_code) = input_code {
-                let path = PathBuf::from(stdin_file_path);
-                Some((path, input_code).into())
-            } else {
-                // we provided the argument without a piped stdin, we bail
-                return Err(CliDiagnostic::missing_argument("stdin", Self::COMMAND_NAME));
-            }
-        } else {
-            None
-        };
-
-        Ok(stdin)
-    }
-
-    // Below, the methods that consumers must implement.
-
-    /// Implements this method if you need to merge CLI arguments to the loaded configuration.
-    ///
-    /// The CLI arguments take precedence over the option configured in the configuration file.
-    fn merge_configuration(
-        &mut self,
-        loaded_configuration: LoadedConfiguration,
-        fs: &DynRef<'_, dyn FileSystem>,
-        console: &mut dyn Console,
-    ) -> Result<PartialConfiguration, WorkspaceError>;
-
-    /// It returns the paths that need to be handled/traversed.
-    fn get_files_to_process(
-        &self,
-        fs: &DynRef<'_, dyn FileSystem>,
-        configuration: &PartialConfiguration,
-    ) -> Result<Vec<OsString>, CliDiagnostic>;
-
-    /// It returns the file path to use in `stdin` mode.
-    fn get_stdin_file_path(&self) -> Option<&str>;
-
-    /// Returns the [Execution] mode.
-    fn get_execution(
-        &self,
-        cli_options: &CliOptions,
-        console: &mut dyn Console,
-        workspace: &dyn Workspace,
-    ) -> Result<Execution, CliDiagnostic>;
-
-    // Below, methods that consumers can implement
-
-    /// Optional method that can be implemented to check if some CLI arguments aren't compatible.
-    ///
-    /// The method is called before loading the configuration from disk.
-    fn check_incompatible_arguments(&self) -> Result<(), CliDiagnostic> {
-        Ok(())
-    }
-}
-
-fn get_files_to_process_with_cli_options(
+pub(crate) fn get_files_to_process_with_cli_options(
     since: Option<&str>,
     changed: bool,
     staged: bool,