Add process-wrap integration (#13)

Adds support for the
[`process-wrap`](https://docs.rs/process-wrap/latest/process_wrap/)
crate.

Author: 9999years

Cargo.lock

@@ -24,6 +24,7 @@ push = false # Don't do `git push`.
 publish = false # Don't do `cargo publish`.
 
 [dependencies]
+process-wrap = { version = "8", features = ["std"], optional = true }
 dyn-clone = "1.0.17"
 shell-words = "1"
 tracing = { version = "0", optional = true }
@@ -33,3 +34,6 @@ utf8-command = "1"
 indoc = "2.0.4"
 pretty_assertions = "1.4.0"
 static_assertions = "1.1.0"
+
+[features]
+default = ["process-wrap"]

Cargo.toml

@@ -19,7 +19,7 @@ use crate::CommandExt;
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum Error {
-    /// An execution failure, when a [`Command`] fails to start.
+    /// An execution failure, when a [`Command`] fails to start or [`Child::wait`].
     Exec(ExecError),
     /// A failure to wait for a [`Command`].
     ///

src/error.rs

@@ -107,3 +107,6 @@ pub use command_ext::CommandExt;
 
 mod child_ext;
 pub use child_ext::ChildExt;
+
+#[cfg(feature = "process-wrap")]
+mod process_wrap;

src/lib.rs

@@ -0,0 +1,110 @@
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::process::Output;
+
+use process_wrap::std::StdChildWrapper;
+use process_wrap::std::StdCommandWrap;
+
+use crate::ChildContext;
+use crate::CommandExt;
+use crate::Error;
+use crate::ExecError;
+use crate::OutputContext;
+use crate::OutputConversionError;
+use crate::OutputLike;
+use crate::Utf8ProgramAndArgs;
+
+impl CommandExt for StdCommandWrap {
+    type Error = Error;
+    type Child = ChildContext<Box<dyn StdChildWrapper>>;
+
+    fn log(&self) -> Result<(), Self::Error> {
+        #[cfg(feature = "tracing")]
+        {
+            let command: Utf8ProgramAndArgs = self.command().into();
+            tracing::debug!(%command, "Executing command");
+        }
+        Ok(())
+    }
+
+    fn output_checked_as<O, R, E>(
+        &mut self,
+        succeeded: impl Fn(OutputContext<O>) -> Result<R, E>,
+    ) -> Result<R, E>
+    where
+        O: Debug + OutputLike + TryFrom<Output> + Send + Sync + 'static,
+        <O as TryFrom<Output>>::Error: Display + Send + Sync,
+        E: From<Self::Error> + Send + Sync,
+    {
+        self.log()?;
+        let displayed: Utf8ProgramAndArgs = self.command().into();
+        let child = match self.spawn() {
+            Ok(child) => child,
+            Err(inner) => {
+                return Err(Error::from(ExecError::new(Box::new(displayed), inner)).into());
+            }
+        };
+
+        match child.wait_with_output() {
+            Ok(output) => match output.try_into() {
+                Ok(output) => succeeded(OutputContext {
+                    output,
+                    command: Box::new(displayed),
+                }),
+                Err(error) => Err(Error::from(OutputConversionError {
+                    command: Box::new(displayed),
+                    inner: Box::new(error),
+                })
+                .into()),
+            },
+            Err(inner) => Err(Error::from(ExecError {
+                command: Box::new(displayed),
+                inner,
+            })
+            .into()),
+        }
+    }
+
+    fn status_checked_as<R, E>(
+        &mut self,
+        succeeded: impl Fn(OutputContext<std::process::ExitStatus>) -> Result<R, E>,
+    ) -> Result<R, E>
+    where
+        E: From<Self::Error>,
+    {
+        self.log()?;
+        let displayed: Utf8ProgramAndArgs = self.command().into();
+        let mut child = match self.spawn() {
+            Ok(child) => child,
+            Err(inner) => {
+                return Err(Error::from(ExecError::new(Box::new(displayed), inner)).into());
+            }
+        };
+
+        match child.wait() {
+            Ok(status) => succeeded(OutputContext {
+                output: status,
+                command: Box::new(displayed),
+            }),
+            Err(inner) => Err(Error::from(ExecError {
+                command: Box::new(displayed),
+                inner,
+            })
+            .into()),
+        }
+    }
+
+    fn spawn_checked(&mut self) -> Result<Self::Child, Self::Error> {
+        let displayed: Utf8ProgramAndArgs = self.command().into();
+        match self.spawn() {
+            Ok(child) => Ok(ChildContext {
+                child,
+                command: Box::new(displayed),
+            }),
+            Err(inner) => Err(Error::from(ExecError {
+                command: Box::new(displayed),
+                inner,
+            })),
+        }
+    }
+}