basic support for 'sh' based execution (#450)

Author: Byron

crate-status.md

@@ -241,7 +241,9 @@ Check out the [performance discussion][git-traverse-performance] as well.
     * [ ] for push
 
 ### git-command
-* [ ] execute commands with `sh`
+* [x] execute commands directly
+* [x] execute commands with `sh`
+* [ ] support for `GIT_EXEC_PATH` environment variable with `git-sec` filter
 
 ### git-note
 

git-command/src/lib.rs

@@ -1,36 +1,77 @@
 #![deny(rust_2018_idioms)]
 #![forbid(unsafe_code)]
-#![allow(dead_code)]
 
 use std::ffi::OsString;
 
 pub struct Prepare {
     command: OsString,
+    stdin: std::process::Stdio,
+    stdout: std::process::Stdio,
+    stderr: std::process::Stdio,
     use_shell: bool,
 }
 
 mod prepare {
     use crate::Prepare;
+    use std::process::Stdio;
 
     /// Builder
     impl Prepare {
+        /// If called, the command will not be executed directly, but with `sh`.
+        ///
+        /// This also allows to pass shell scripts as command, or use commands that contain arguments which are subsequently
+        /// parsed by `sh`.
         pub fn with_shell(mut self) -> Self {
             self.use_shell = true;
             self
         }
+
+        /// Configure the process to use `stdio` for _stdin.
+        pub fn stdin(mut self, stdio: Stdio) -> Self {
+            self.stdin = stdio;
+            self
+        }
+        /// Configure the process to use `stdio` for _stdout_.
+        pub fn stdout(mut self, stdio: Stdio) -> Self {
+            self.stdout = stdio;
+            self
+        }
+        /// Configure the process to use `stdio` for _stderr.
+        pub fn stderr(mut self, stdio: Stdio) -> Self {
+            self.stderr = stdio;
+            self
+        }
     }
 
     /// Finalization
     impl Prepare {
         pub fn spawn(self) -> std::io::Result<std::process::Child> {
-            todo!("create command and spawn that")
+            let mut cmd = if self.use_shell {
+                let mut cmd = std::process::Command::new(if cfg!(windows) { "sh" } else { "/bin/sh" });
+                cmd.arg("-c");
+                cmd.arg(self.command);
+                cmd
+            } else {
+                std::process::Command::new(self.command)
+            };
+            cmd.stdin(self.stdin).stdout(self.stdout).stderr(self.stderr);
+            cmd.spawn()
         }
     }
 }
 
+/// Prepare `cmd` for [spawning][Process::spawn()] by configuring it with various builder methods.
+///
+/// Note that the default IO is configured for typical API usage, that is
+///
+/// - `stdin` is null
+/// - `stdout` and `stderr` are captured.
 pub fn prepare(cmd: impl Into<OsString>) -> Prepare {
     Prepare {
         command: cmd.into(),
+        stdin: std::process::Stdio::null(),
+        stdout: std::process::Stdio::piped(),
+        stderr: std::process::Stdio::piped(),
         use_shell: false,
     }
 }

git-command/tests/command.rs

@@ -1,20 +1,37 @@
+use git_testtools::Result;
+
 mod spawn {
     #[test]
-    #[ignore]
-    fn direct_command_execution_searches_in_path() {
-        git_command::prepare(if cfg!(unix) { "ls" } else { "dir.exe" })
-            .spawn()
-            .unwrap();
+    fn direct_command_execution_searches_in_path() -> crate::Result {
+        assert!(git_command::prepare(if cfg!(unix) { "ls" } else { "dir.exe" })
+            .spawn()?
+            .wait()?
+            .success());
+        Ok(())
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn direct_command_with_absolute_command_path() -> crate::Result {
+        assert!(git_command::prepare("/bin/ls").spawn()?.wait()?.success());
+        Ok(())
     }
 
     mod with_shell {
         #[test]
-        #[ignore]
-        fn command_in_path_with_args() {
-            git_command::prepare(if cfg!(unix) { "ls -l" } else { "dir.exe -a" })
+        fn command_in_path_with_args() -> crate::Result {
+            assert!(git_command::prepare(if cfg!(unix) { "ls -l" } else { "dir.exe -a" })
                 .with_shell()
-                .spawn()
-                .unwrap();
+                .spawn()?
+                .wait()?
+                .success());
+            Ok(())
+        }
+
+        #[test]
+        fn sh_shell_specific_script_code() -> crate::Result {
+            assert!(git_command::prepare(":;:;:").with_shell().spawn()?.wait()?.success());
+            Ok(())
         }
     }
 }