Merge pull request #21 from epage/fail

Remove `failure` from API

Author: epage

Cargo.toml

@@ -15,10 +15,8 @@ keywords = ["cli", "test", "assert", "command", "duct"]
 name = "bin_fixture"
 
 [dependencies]
-failure = "0.1"
-failure_derive = "0.1"
 predicates = "0.5.1"
-escargot = "0.1"
+escargot = "0.2"
 serde = { version = "1.0", features = ["derive"] }
 
 [dev-dependencies]

examples/example_fixture.rs

@@ -1,13 +1,10 @@
-extern crate failure;
-
 use std::env;
+use std::error::Error;
 use std::io;
 use std::io::Write;
 use std::process;
 
-use failure::ResultExt;
-
-fn run() -> Result<(), failure::Error> {
+fn run() -> Result<(), Box<Error>> {
     if let Ok(text) = env::var("stdout") {
         println!("{}", text);
     }
@@ -18,8 +15,7 @@ fn run() -> Result<(), failure::Error> {
     let code = env::var("exit")
         .ok()
         .map(|v| v.parse::<i32>())
-        .map_or(Ok(None), |r| r.map(Some))
-        .context("Invalid exit code")?
+        .map_or(Ok(None), |r| r.map(Some))?
         .unwrap_or(0);
     process::exit(code);
 }

src/bin/bin_fixture.rs

@@ -1,13 +1,10 @@
-extern crate failure;
-
 use std::env;
+use std::error::Error;
 use std::io;
 use std::io::Write;
 use std::process;
 
-use failure::ResultExt;
-
-fn run() -> Result<(), failure::Error> {
+fn run() -> Result<(), Box<Error>> {
     if let Ok(text) = env::var("stdout") {
         println!("{}", text);
     }
@@ -18,8 +15,7 @@ fn run() -> Result<(), failure::Error> {
     let code = env::var("exit")
         .ok()
         .map(|v| v.parse::<i32>())
-        .map_or(Ok(None), |r| r.map(Some))
-        .context("Invalid exit code")?
+        .map_or(Ok(None), |r| r.map(Some))?
         .unwrap_or(0);
     process::exit(code);
 }

src/cargo.rs

@@ -12,12 +12,13 @@
 //!     .unwrap();
 //! ```
 
+use std::error::Error;
 use std::ffi;
+use std::fmt;
 use std::path;
 use std::process;
 
 use escargot;
-use failure;
 
 /// Create a `Command` for a `bin` in the Cargo project.
 pub trait CommandCargoExt
@@ -39,7 +40,7 @@ where
     ///     .unwrap()
     ///     .unwrap();
     /// ```
-    fn main_binary() -> Result<Self, failure::Error>;
+    fn main_binary() -> Result<Self, CargoError>;
 
     /// Create a `Command` to run a specific binary of the current crate.
     ///
@@ -54,7 +55,7 @@ where
     ///     .unwrap()
     ///     .unwrap();
     /// ```
-    fn cargo_bin<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, failure::Error>;
+    fn cargo_bin<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, CargoError>;
 
     /// Create a `Command` to run a specific example of the current crate.
     ///
@@ -69,21 +70,21 @@ where
     ///     .unwrap()
     ///     .unwrap();
     /// ```
-    fn cargo_example<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, failure::Error>;
+    fn cargo_example<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, CargoError>;
 }
 
 impl CommandCargoExt for process::Command {
-    fn main_binary() -> Result<Self, failure::Error> {
+    fn main_binary() -> Result<Self, CargoError> {
         let cmd = main_binary_path()?;
         Ok(process::Command::new(&cmd))
     }
 
-    fn cargo_bin<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, failure::Error> {
+    fn cargo_bin<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, CargoError> {
         let cmd = cargo_bin_path(name)?;
         Ok(process::Command::new(&cmd))
     }
 
-    fn cargo_example<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, failure::Error> {
+    fn cargo_example<S: AsRef<ffi::OsStr>>(name: S) -> Result<Self, CargoError> {
         let cmd = cargo_example_path(name)?;
         Ok(process::Command::new(&cmd))
     }
@@ -126,41 +127,103 @@ fn extract_filenames(msg: &escargot::Message, kind: &str) -> Option<path::PathBu
 /// Get the path to the crate's main binary.
 ///
 /// Note: only works if there one bin in the crate.
-pub fn main_binary_path() -> Result<path::PathBuf, failure::Error> {
+pub fn main_binary_path() -> Result<path::PathBuf, CargoError> {
     let cargo = escargot::Cargo::new().build().current_release();
     let bins: Vec<_> = cargo
-        .exec()?
+        .exec()
+        .map_err(|e| CargoError::with_cause(e))?
         .filter_map(|m| extract_filenames(&m, "bin"))
         .collect();
     if bins.is_empty() {
-        bail!("No binaries in crate");
+        return Err(CargoError::with_context("No binaries in crate"));
     } else if bins.len() != 1 {
-        bail!("Ambiguous which binary is intended: {:?}", bins);
+        return Err(CargoError::with_context(format!(
+            "Ambiguous which binary is intended: {:?}",
+            bins
+        )));
     }
     Ok(bins.into_iter().next().expect("already validated"))
 }
 
 /// Get the path to the specified binary of the current crate.
-pub fn cargo_bin_path<S: AsRef<ffi::OsStr>>(name: S) -> Result<path::PathBuf, failure::Error> {
+pub fn cargo_bin_path<S: AsRef<ffi::OsStr>>(name: S) -> Result<path::PathBuf, CargoError> {
     let cargo = escargot::Cargo::new().build().bin(name).current_release();
     let bins: Vec<_> = cargo
-        .exec()?
+        .exec()
+        .map_err(|e| CargoError::with_cause(e))?
         .filter_map(|m| extract_filenames(&m, "bin"))
         .collect();
     assert_eq!(bins.len(), 1);
     Ok(bins.into_iter().next().expect("already validated"))
 }
 
 /// Get the path to the specified example of the current crate.
-pub fn cargo_example_path<S: AsRef<ffi::OsStr>>(name: S) -> Result<path::PathBuf, failure::Error> {
+pub fn cargo_example_path<S: AsRef<ffi::OsStr>>(name: S) -> Result<path::PathBuf, CargoError> {
     let cargo = escargot::Cargo::new()
         .build()
         .example(name)
         .current_release();
     let bins: Vec<_> = cargo
-        .exec()?
+        .exec()
+        .map_err(|e| CargoError::with_cause(e))?
         .filter_map(|m| extract_filenames(&m, "example"))
         .collect();
     assert_eq!(bins.len(), 1);
     Ok(bins.into_iter().next().expect("already validated"))
 }
+
+/// Error when finding crate binary.
+#[derive(Debug)]
+pub struct CargoError {
+    context: Option<String>,
+    cause: Option<Box<Error + Send + Sync + 'static>>,
+}
+
+impl CargoError {
+    fn with_context<S>(context: S) -> Self
+    where
+        S: Into<String>,
+    {
+        let context = context.into();
+        Self {
+            context: Some(context),
+            cause: None,
+        }
+    }
+
+    fn with_cause<E>(cause: E) -> Self
+    where
+        E: Error + Send + Sync + 'static,
+    {
+        let cause = Box::new(cause);
+        Self {
+            context: None,
+            cause: Some(cause),
+        }
+    }
+}
+
+impl Error for CargoError {
+    fn description(&self) -> &str {
+        "Cargo command failed."
+    }
+
+    fn cause(&self) -> Option<&Error> {
+        self.cause.as_ref().map(|c| {
+            let c: &Error = c.as_ref();
+            c
+        })
+    }
+}
+
+impl fmt::Display for CargoError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref context) = self.context {
+            writeln!(f, "{}", context)?;
+        }
+        if let Some(ref cause) = self.cause {
+            writeln!(f, "Cause: {}", cause)?;
+        }
+        Ok(())
+    }
+}

src/errors.rs

@@ -1,9 +1,8 @@
+use std::error::Error;
 use std::fmt;
 use std::process;
 use std::str;
 
-use failure;
-
 /// `std::process::Output` represented as a `Result`.
 ///
 /// # Examples
@@ -34,15 +33,15 @@ pub type OutputResult = Result<process::Output, OutputError>;
 ///     .env("exit", "42")
 ///     .unwrap_err();
 /// ```
-#[derive(Fail, Debug)]
+#[derive(Debug)]
 pub struct OutputError {
     cmd: Option<String>,
     stdin: Option<Vec<u8>>,
     cause: OutputCause,
 }
 
 impl OutputError {
-    /// Convert `std::process::Output` into a `Fail`.
+    /// Convert `std::process::Output` into an `Error`.
     pub fn new(output: process::Output) -> Self {
         Self {
             cmd: None,
@@ -54,12 +53,12 @@ impl OutputError {
     /// For errors that happen in creating a `std::process::Output`.
     pub fn with_cause<E>(cause: E) -> Self
     where
-        E: Into<failure::Error>,
+        E: Error + Send + Sync + 'static,
     {
         Self {
             cmd: None,
             stdin: None,
-            cause: OutputCause::Unexpected(cause.into()),
+            cause: OutputCause::Unexpected(Box::new(cause)),
         }
     }
 
@@ -101,6 +100,19 @@ impl OutputError {
     }
 }
 
+impl Error for OutputError {
+    fn description(&self) -> &str {
+        "Command failed."
+    }
+
+    fn cause(&self) -> Option<&Error> {
+        if let &OutputCause::Unexpected(ref err) = &self.cause {
+            Some(err.as_ref())
+        } else {
+            None
+        }
+    }
+}
 impl fmt::Display for OutputError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(ref cmd) = self.cmd {
@@ -120,7 +132,7 @@ impl fmt::Display for OutputError {
 #[derive(Debug)]
 enum OutputCause {
     Expected(Output),
-    Unexpected(failure::Error),
+    Unexpected(Box<Error + Send + Sync + 'static>),
 }
 
 impl fmt::Display for OutputCause {
@@ -133,7 +145,7 @@ impl fmt::Display for OutputCause {
 }
 
 /// Wrap `Output` to be `Dislay`able.
-#[derive(Fail, Debug)]
+#[derive(Debug)]
 struct Output {
     output: process::Output,
 }

src/lib.rs

@@ -37,10 +37,6 @@
 #![warn(missing_docs)]
 
 extern crate escargot;
-#[macro_use]
-extern crate failure;
-#[macro_use]
-extern crate failure_derive;
 extern crate predicates;
 #[macro_use]
 extern crate serde;