feat: run commands in all repositories despite failures

Author: marcfrederick

CHANGELOG.md

@@ -8,10 +8,12 @@ All notable changes to this project will be documented in this file.
 
 - Simplified the project from a two-crate workspace into a single binary crate.
 - Prevented repository discovery from traversing `.git` metadata directories.
+- Reported all parallel command failures in a summary.
 
 ### Fixed
 
 - Corrected `--hidden` to include hidden directories and `--no-ignore` to disable all standard ignore rules.
+- Preserved process startup errors and let clap handle help, version, and usage output.
 
 ## Version 0.4.5 - 2025-07-02
 

README.md

@@ -19,12 +19,16 @@ For instance, if you want to execute git pull in each repository, you would use:
 git-foreach "git pull"
 ```
 
-By default, git-foreach will stop executing if the command fails in one of the repositories. If you want the execution
-to continue despite failures, you can append `|| :` to the command. This will mask the error and allows git-foreach to
-continue processing the remaining repositories.
+Commands run in parallel in every discovered repository. A failure in one repository does not stop commands that run
+in the others. After all commands finish, failures are reported and `git-foreach` exits unsuccessfully. To mask failures,
+you can append `|| :` to the command.
 
 ```shell
-git-foreach "git pull || :"
+$ git-foreach "git pull"
+encountered 1 error(s):
+- command exited unsuccessfully in ./example-repository: exit status: 1
+
+$ git-foreach "git pull || :"
 ```
 
 ## Installation

src/error.rs

@@ -1,56 +1,38 @@
+use std::io;
 use std::path::PathBuf;
+use std::process::ExitStatus;
 
 #[derive(Debug)]
 pub enum Error {
-    CommandExecutionFailed { path: PathBuf },
-    CommandExecutionFailedWithNonZeroExitCode { path: PathBuf, exit_code: i32 },
+    CommandExecutionFailed { path: PathBuf, source: io::Error },
+    CommandExitedUnsuccessfully { path: PathBuf, status: ExitStatus },
     Walk(ignore::Error),
-    InvalidUsage(clap::Error),
-}
-
-impl Error {
-    /// Get the exit code for the error.
-    fn get_exit_code(&self) -> i32 {
-        match self {
-            Self::CommandExecutionFailedWithNonZeroExitCode { exit_code, .. } => *exit_code,
-            Self::InvalidUsage(source) => source.exit_code(),
-            _ => 1,
-        }
-    }
-
-    /// Print the error message and exit with the appropriate exit code.
-    pub fn print_and_exit(&self) {
-        eprintln!("{self}");
-        std::process::exit(self.get_exit_code());
-    }
 }
 
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Self::CommandExecutionFailed { path } => {
-                write!(f, "run_command failed for {}", path.display())
+            Self::CommandExecutionFailed { path, source } => {
+                write!(f, "failed to start command in {}: {source}", path.display())
             }
-            Self::CommandExecutionFailedWithNonZeroExitCode { path, exit_code } => {
+            Self::CommandExitedUnsuccessfully { path, status } => {
                 write!(
                     f,
-                    "run_command failed with non-zero exit code {} for {}",
-                    exit_code,
-                    path.display()
+                    "command exited unsuccessfully in {}: {status}",
+                    path.display(),
                 )
             }
-            Self::Walk(source) => write!(f, "error walking directory: {source}"),
-            Self::InvalidUsage(source) => write!(f, "{source}"),
+            Self::Walk(source) => write!(f, "failed to walk directory: {source}"),
         }
     }
 }
 
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
+            Self::CommandExecutionFailed { source, .. } => Some(source),
             Self::Walk(source) => Some(source),
-            Self::InvalidUsage(source) => Some(source),
-            _ => None,
+            Self::CommandExitedUnsuccessfully { .. } => None,
         }
     }
 }
@@ -60,9 +42,3 @@ impl From<ignore::Error> for Error {
         Self::Walk(source)
     }
 }
-
-impl From<clap::Error> for Error {
-    fn from(source: clap::Error) -> Self {
-        Self::InvalidUsage(source)
-    }
-}

src/main.rs

@@ -1,9 +1,9 @@
 #![forbid(unsafe_code)]
 #![deny(clippy::pedantic)]
 
-use std::env;
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
+use std::process::ExitCode;
 
 use clap::Parser;
 use ignore::WalkBuilder;
@@ -48,24 +48,46 @@ struct Options {
     command: Vec<String>,
 }
 
-fn main() {
-    repository_foreach(env::args()).unwrap_or_else(|err| err.print_and_exit());
+fn main() -> ExitCode {
+    let options = Options::parse();
+
+    match repository_foreach(&options) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(errors) => {
+            eprintln!("encountered {} error(s):", errors.len());
+            for error in errors {
+                eprintln!("- {error}");
+            }
+            ExitCode::FAILURE
+        }
+    }
 }
 
-/// Run a command in each git repository in the current directory and its
+/// Run a command in each git repository in the given directory and its
 /// subdirectories.
-fn repository_foreach<T: Iterator<Item = String>>(args: T) -> Result<(), Error> {
-    let options = parse_options(args)?;
-
-    repository_walk(&options)
+fn repository_foreach(options: &Options) -> Result<(), Vec<Error>> {
+    let mut errors: Vec<_> = repository_walk(options)
         .par_bridge()
-        .try_for_each(|entry| {
-            let path = entry?.into_path();
+        .filter_map(|entry| {
+            let path = match entry {
+                Ok(entry) => entry.into_path(),
+                Err(source) => return Some(Error::from(source)),
+            };
+
             if path.is_dir() && path.join(".git").exists() {
-                run_command_in_directory(&options, &path)?;
+                run_command_in_directory(options, &path).err()
+            } else {
+                None
             }
-            Ok(())
         })
+        .collect();
+
+    errors.sort_by_key(ToString::to_string);
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors)
+    }
 }
 
 fn repository_walk(options: &Options) -> ignore::Walk {
@@ -76,11 +98,6 @@ fn repository_walk(options: &Options) -> ignore::Walk {
         .build()
 }
 
-/// Parse the command line options.
-fn parse_options<T: Iterator<Item = String>>(args: T) -> Result<Options, Error> {
-    Options::try_parse_from(args).map_err(Error::from)
-}
-
 /// Run a command in a directory.
 fn run_command_in_directory(options: &Options, path: &Path) -> Result<(), Error> {
     if !options.quiet {
@@ -109,60 +126,60 @@ fn run_command_in_directory(options: &Options, path: &Path) -> Result<(), Error>
     let status = std::process::Command::new(shell_binary)
         .args([shell_arg, &shell_command])
         .current_dir(path)
-        .status();
-
-    match status {
-        Ok(exit_status) if exit_status.success() => Ok(()),
-        Ok(exit_status) => Err(Error::CommandExecutionFailedWithNonZeroExitCode {
+        .status()
+        .map_err(|source| Error::CommandExecutionFailed {
             path: path.to_path_buf(),
-            exit_code: exit_status.code().unwrap_or(1),
-        }),
-        Err(_) => Err(Error::CommandExecutionFailed {
+            source,
+        })?;
+
+    if status.success() {
+        Ok(())
+    } else {
+        Err(Error::CommandExitedUnsuccessfully {
             path: path.to_path_buf(),
-        }),
+            status,
+        })
     }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
+    use clap::error::ErrorKind;
     use std::fs;
     use tempfile::tempdir;
 
-    macro_rules! parse_options_tests {
-        ($($name:ident: $args:expr => $foo:expr,)*) => {
+    macro_rules! parse_error_tests {
+        ($($name:ident: $args:expr => $kind:expr,)*) => {
         $(
             #[test]
             fn $name() {
                 let args = $args.iter().map(ToString::to_string);
-                let result = parse_options(args);
-                $foo(result);
+                let error = Options::try_parse_from(args).expect_err("expected parsing to fail");
+                assert_eq!(error.kind(), $kind);
             }
         )*
         }
     }
 
-    parse_options_tests!(
-        parse_options_empty: [] as [&str; 0] => |result: Result<_, _>| assert!(matches!(result, Err(Error::InvalidUsage { .. }))),
-        parse_options_help: ["git-foreach", "--help"] => |result: Result<_, _>| assert!(matches!(result, Err(Error::InvalidUsage { .. }))),
-        parse_options_version: ["git-foreach", "--version"] => |result: Result<_, _>| assert!(matches!(result, Err(Error::InvalidUsage { .. }))),
-        parse_options_invalid: ["git-foreach", "--invalid"] => |result: Result<_, _>| assert!(matches!(result, Err(Error::InvalidUsage { .. }))),
-        parse_options_valid: ["git-foreach", "echo", "hello"] => |result: Result<Options, _>| {
-            let options = result.expect("Expected Ok(_)");
-            assert_eq!(options.command, vec!["echo".to_string(), "hello".to_string()]);
-        },
-        parse_options_dry_run: ["git-foreach", "--dry-run", "echo", "hello"] => |result: Result<Options, _>| {
-            let options = result.expect("Expected Ok(_)");
-            assert!(options.dry_run);
-            assert_eq!(options.command, vec!["echo".to_string(), "hello".to_string()]);
-        },
-        parse_options_quiet: ["git-foreach", "--quiet", "echo", "hello"] => |result: Result<Options, _>| {
-            let options = result.expect("Expected Ok(_)");
-            assert!(options.quiet);
-            assert_eq!(options.command, vec!["echo".to_string(), "hello".to_string()]);
-        },
+    parse_error_tests!(
+        parse_options_empty: [] as [&str; 0] => ErrorKind::MissingRequiredArgument,
+        parse_options_help: ["git-foreach", "--help"] => ErrorKind::DisplayHelp,
+        parse_options_version: ["git-foreach", "--version"] => ErrorKind::DisplayVersion,
+        parse_options_invalid: ["git-foreach", "--invalid"] => ErrorKind::UnknownArgument,
     );
 
+    #[test]
+    fn parse_options() {
+        let options =
+            Options::try_parse_from(["git-foreach", "--dry-run", "--quiet", "echo", "hello"])
+                .expect("expected parsing to succeed");
+
+        assert!(options.dry_run);
+        assert!(options.quiet);
+        assert_eq!(options.command, ["echo", "hello"]);
+    }
+
     #[test]
     fn hidden_repositories_are_only_included_when_requested() {
         let directory = tempdir().expect("failed to create temporary directory");
@@ -208,7 +225,6 @@ mod test {
 
         repository_walk(&options)
             .map(|entry| entry.expect("failed to walk test directory").into_path())
-            .into_iter()
             .filter(|path| path.is_dir() && path.join(".git").exists())
             .collect()
     }