Implement stdin support (#471)

* Implement stdin support

* `&&` not `&`

* Missing `,`

* Clean up style

* Add empty stdin test

* Add more relevant permissions

* Fix misleading test case

* Update snapshots for shell completion

Author: DavisVaughan

.claude/settings.json

@@ -3,20 +3,24 @@
   "permissions": {
     "defaultMode": "acceptEdits",
     "allow": [
+      "Bash(cargo insta accept:*)",
       "Bash(cat:*)",
       "Bash(find:*)",
       "Bash(gh issue list:*)",
       "Bash(gh issue view:*)",
       "Bash(gh pr diff:*)",
       "Bash(gh pr view:*)",
       "Bash(git checkout:*)",
+      "Bash(git diff:*)",
       "Bash(git grep:*)",
+      "Bash(git log:*)",
       "Bash(grep:*)",
+      "Bash(just test:*)",
       "Bash(ls:*)",
       "Bash(rm:*)",
       "Bash(sed:*)",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:raw.githubusercontent.com)"
+      "WebFetch",
+      "WebSearch"
     ]
   }
 }

crates/air/src/args.rs

@@ -54,6 +54,15 @@ pub(crate) struct FormatCommand {
     /// and zero otherwise.
     #[arg(long)]
     pub check: bool,
+
+    /// Use this option to enable reading from stdin and writing to stdout. This specifies
+    /// a file path to associate the standard input with, which is used as the location to
+    /// begin searching for configuration files from. The file does not have to exist and
+    /// will not be read from. If a relative path is provided, it is resolved from the
+    /// current working directory. If this option is specified, no other files or
+    /// directories can be provided.
+    #[arg(long)]
+    pub stdin_file_path: Option<PathBuf>,
 }
 
 #[derive(Clone, Debug, Parser)]

crates/air/src/commands/format.rs

@@ -1,89 +1,43 @@
-use std::fmt::Display;
-use std::fmt::Formatter;
-use std::io;
-use std::io::Write;
-use std::io::stderr;
-use std::path::Path;
-use std::path::PathBuf;
-
-use colored::Colorize;
-use fs::relativize_path;
-use itertools::Either;
-use itertools::Itertools;
-use thiserror::Error;
-use workspace::discovery::DiscoveredSettings;
-use workspace::discovery::discover_r_file_paths;
-use workspace::discovery::discover_settings;
-use workspace::format::FormatFileError;
-use workspace::format::FormattedFile;
-use workspace::format::format_file;
-use workspace::resolve::PathResolver;
-use workspace::settings::FormatSettings;
-use workspace::settings::Settings;
-
 use crate::ExitStatus;
 use crate::args::FormatCommand;
 
+mod paths;
+mod stdin;
+
 #[derive(Copy, Clone, Debug)]
 enum FormatMode {
     Write,
     Check,
 }
 
-#[derive(Error, Debug)]
-enum FormatPathError {
-    FormatFile(PathBuf, FormatFileError),
-    Write(PathBuf, io::Error),
-    Ignore(#[from] ignore::Error),
-}
-
 pub(crate) fn format(command: FormatCommand) -> anyhow::Result<ExitStatus> {
-    let mode = FormatMode::from_command(&command);
-
-    let mut resolver = PathResolver::new(Settings::default());
-
-    for DiscoveredSettings {
-        directory,
-        settings,
-    } in discover_settings(&command.paths)?
-    {
-        resolver.add(&directory, settings);
+    if let Some(status) = check_argument_consistency(&command) {
+        return Ok(status);
     }
 
-    match mode {
-        FormatMode::Write => {
-            let errors = format_paths_write(&command.paths, &resolver);
-
-            for error in &errors {
-                tracing::error!("{error}");
-            }
-
-            if errors.is_empty() {
-                Ok(ExitStatus::Success)
-            } else {
-                Ok(ExitStatus::Error)
-            }
-        }
-        FormatMode::Check => {
-            let (paths, errors) = format_paths_check(&command.paths, &resolver);
-
-            for error in &errors {
-                tracing::error!("{error}");
-            }
+    let mode = FormatMode::from_command(&command);
 
-            inform_changed(&paths, &mut stderr().lock())?;
+    match command.stdin_file_path {
+        Some(path) => stdin::format(path, mode),
+        None => paths::format(command.paths, mode),
+    }
+}
 
-            if errors.is_empty() {
-                if paths.is_empty() {
-                    Ok(ExitStatus::Success)
-                } else {
-                    Ok(ExitStatus::Failure)
-                }
-            } else {
-                Ok(ExitStatus::Error)
-            }
-        }
+fn check_argument_consistency(command: &FormatCommand) -> Option<ExitStatus> {
+    if command.stdin_file_path.is_some() && !command.paths.is_empty() {
+        tracing::error!(
+            "Can't supply paths when reading from stdin: {paths}",
+            paths = command
+                .paths
+                .iter()
+                .map(|path| format!("'{path}'", path = path.display()))
+                .collect::<Vec<String>>()
+                .join(",")
+        );
+        return Some(ExitStatus::Error);
     }
+
+    None
 }
 
 impl FormatMode {
@@ -95,134 +49,3 @@ impl FormatMode {
         }
     }
 }
-
-fn inform_changed(paths: &[PathBuf], f: &mut impl Write) -> io::Result<()> {
-    for path in paths.iter().sorted_unstable() {
-        writeln!(
-            f,
-            "Would reformat: {path}",
-            path = relativize_path(path).underline()
-        )?;
-    }
-    Ok(())
-}
-
-fn format_paths_write<P: AsRef<Path>>(
-    paths: &[P],
-    resolver: &PathResolver<Settings>,
-) -> Vec<FormatPathError> {
-    let paths = discover_r_file_paths(paths, resolver, true);
-
-    paths
-        .into_iter()
-        .filter_map(|path| match path {
-            Ok(path) => {
-                let settings = resolver.resolve_or_fallback(&path);
-                match format_path(&path, &settings.format) {
-                    Ok(file) => match write_path(&path, file) {
-                        Ok(()) => None,
-                        Err(err) => Some(FormatPathError::Write(path, err)),
-                    },
-                    Err(err) => Some(FormatPathError::FormatFile(path, err)),
-                }
-            }
-            Err(err) => Some(err.into()),
-        })
-        .collect()
-}
-
-fn format_paths_check<P: AsRef<Path>>(
-    paths: &[P],
-    resolver: &PathResolver<Settings>,
-) -> (Vec<PathBuf>, Vec<FormatPathError>) {
-    let paths = discover_r_file_paths(paths, resolver, true);
-
-    paths
-        .into_iter()
-        .filter_map(|path| match path {
-            Ok(path) => {
-                let settings = resolver.resolve_or_fallback(&path);
-                match format_path(&path, &settings.format) {
-                    Ok(file) => check_path(path, file).map(Ok),
-                    Err(err) => Some(Err(FormatPathError::FormatFile(path, err))),
-                }
-            }
-            Err(err) => Some(Err(err.into())),
-        })
-        .partition_map(|result| match result {
-            Ok(result) => Either::Left(result),
-            Err(err) => Either::Right(err),
-        })
-}
-
-fn format_path<P: AsRef<Path>>(
-    path: P,
-    settings: &FormatSettings,
-) -> std::result::Result<FormattedFile, FormatFileError> {
-    let path = path.as_ref();
-    tracing::trace!("Formatting {path}", path = path.display());
-    format_file(path, settings)
-}
-
-/// Returns `Ok(())` if the format results were successfully written back, otherwise
-/// returns an error
-fn write_path<P: AsRef<Path>>(path: P, file: FormattedFile) -> io::Result<()> {
-    match file {
-        FormattedFile::Changed(file) => std::fs::write(path, file.new()),
-        FormattedFile::Unchanged => Ok(()),
-    }
-}
-
-/// Returns `Some(path)` if a change occurred, otherwise returns `None`
-fn check_path(path: PathBuf, file: FormattedFile) -> Option<PathBuf> {
-    match file {
-        FormattedFile::Changed(_) => Some(path),
-        FormattedFile::Unchanged => None,
-    }
-}
-
-impl Display for FormatPathError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::FormatFile(path, err) => match err {
-                FormatFileError::Format(err) => write!(
-                    f,
-                    "Failed to format {path}: {err}",
-                    path = relativize_path(path).underline(),
-                ),
-                FormatFileError::Read(err) => write!(
-                    f,
-                    "Failed to read {path}: {err}",
-                    path = relativize_path(path).underline(),
-                ),
-            },
-            Self::Ignore(err) => {
-                if let ignore::Error::WithPath { path, .. } = err {
-                    write!(
-                        f,
-                        "Failed to format {path}: {err}",
-                        path = relativize_path(path).underline(),
-                        err = err
-                            .io_error()
-                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
-                    )
-                } else {
-                    write!(
-                        f,
-                        "Encountered error: {err}",
-                        err = err
-                            .io_error()
-                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
-                    )
-                }
-            }
-            Self::Write(path, err) => {
-                write!(
-                    f,
-                    "Failed to write {path}: {err}",
-                    path = relativize_path(path).underline(),
-                )
-            }
-        }
-    }
-}