OutputContext: Add new, into_output_and_command, and output_error (#28)

I learned it's actually impossible (!) for consumers to implement
`CommandExt` because there are no public constructors for
[`OutputContext`]. Similarly, the lack of a public `maybe_error_message`
method requires a tedious workaround.

This introduces several new methods to fix these deficiencies:

- `OutputContext::new` lets you construct an `OutputContext`.

- `OutputContext::into_output_and_command` lets you deconstruct an
`OutputContext`. Previously, both these fields were accessible with
`into_output` and `into_command`, but you could only call one of those
methods, because they both take an owned `self` receiver.

- `OutputContext::output_error` is like `OutputContext::error`, but it
doesn't wrap the output in an `Error`, letting you use the
`OutputError::with_message` method.

Author: 9999years

src/output_context.rs

@@ -34,6 +34,11 @@ impl<O> OutputContext<O>
 where
     O: OutputLike + Send + Sync + 'static,
 {
+    /// Construct a new [`OutputContext`].
+    pub fn new(output: O, command: Box<dyn CommandDisplay + Send + Sync>) -> Self {
+        Self { output, command }
+    }
+
     /// Get the [`OutputLike`] data contained in this context object.
     pub fn into_output(self) -> O {
         self.output
@@ -61,12 +66,31 @@ where
         self.command
     }
 
+    /// Get the output and command contained in this context object.
+    ///
+    /// Unlike [`OutputContext::into_output`] and [`OutputContext::into_command`], this lets you
+    /// extract both fields.
+    pub fn into_output_and_command(self) -> (O, Box<dyn CommandDisplay>) {
+        (self.output, self.command)
+    }
+
     /// Construct an error that indicates this command failed, containing information about the
     /// command and its output.
     ///
     /// See [`CommandExt`] for examples of the error format.
+    ///
+    /// This is a thin wrapper around [`OutputContext::output_error`].
     pub fn error(self) -> Error {
-        Error::from(OutputError::new(self.command, Box::new(self.output)))
+        Error::from(self.output_error())
+    }
+
+    /// Construct an error that indicates this command failed, containing information about the
+    /// command and its output.
+    ///
+    /// This is like [`OutputContext::error`], but it returns the inner [`OutputError`] directly,
+    /// rather than wrapping it in an [`Error`].
+    pub fn output_error(self) -> OutputError {
+        OutputError::new(self.command, Box::new(self.output))
     }
 
     /// Construct an error that indicates this command failed, containing information about the
@@ -86,7 +110,7 @@ where
     where
         E: Debug + Display + Send + Sync + 'static,
     {
-        let ret = OutputError::new(self.command, Box::new(self.output));
+        let ret = self.output_error();
         Error::from(match message {
             Some(message) => ret.with_message(Box::new(message)),
             None => ret,