refactor: Migrate to failure

This takes the use of `Context` to a bit of an extreme, using a single
error type and propogating any additional information along as
individual pieces of `Context.

Example:
```
command="wc" "README.md"
with: stderr='''wc: README.md: No such file or directory
'''
with: stdout=''''''
with: expected to succeed
with: CLI Assertion Error: Status mismatch.
```

BREAKING CHANGE: The error type of `Assert` is now `failure::Error`.

Author: epage

Cargo.toml

@@ -18,7 +18,8 @@ name = "assert_fixture"
 [dependencies]
 colored = "1.5"
 difference = "2.0"
-error-chain = "0.11"
+failure = "0.1"
+failure_derive = "0.1"
 serde_json = "1.0"
 environment = "0.1"
 

src/assert.rs

@@ -1,14 +1,17 @@
-use environment::Environment;
-use error_chain::ChainedError;
-use errors::*;
-use output::{Content, Output, OutputKind, OutputPredicate};
 use std::default;
 use std::ffi::{OsStr, OsString};
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::vec::Vec;
 
+use environment::Environment;
+use failure;
+use failure::ResultExt;
+
+use errors::*;
+use output::{Content, Output, OutputKind, OutputPredicate};
+
 /// Assertions for a specific command.
 #[derive(Debug)]
 #[must_use]
@@ -342,9 +345,7 @@ impl Assert {
             None => command,
         };
 
-        let mut spawned = command
-            .spawn()
-            .chain_err(|| ErrorKind::SpawnFailed(self.cmd.clone()))?;
+        let mut spawned = command.spawn().context(AssertionKind::Spawn)?;
 
         if let Some(ref contents) = self.stdin_contents {
             spawned
@@ -359,25 +360,41 @@ impl Assert {
             if expect_success != output.status.success() {
                 let out = String::from_utf8_lossy(&output.stdout).to_string();
                 let err = String::from_utf8_lossy(&output.stderr).to_string();
-                let err: Error = ErrorKind::StatusMismatch(expect_success, out, err).into();
-                bail!(err.chain_err(|| ErrorKind::AssertionFailed(self.cmd.clone())));
+                Err(AssertionError::new(AssertionKind::StatusMismatch))
+                    .context(if expect_success {
+                        "expected to succeed"
+                    } else {
+                        "expected to fail"
+                    })
+                    .context(KeyValueDisplay::new("stdout", QuotedDisplay::new(out)))
+                    .context(KeyValueDisplay::new("stderr", QuotedDisplay::new(err)))
+                    .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))?;
             }
         }
 
         if self.expect_exit_code.is_some() && self.expect_exit_code != output.status.code() {
             let out = String::from_utf8_lossy(&output.stdout).to_string();
             let err = String::from_utf8_lossy(&output.stderr).to_string();
-            let err: Error =
-                ErrorKind::ExitCodeMismatch(self.expect_exit_code, output.status.code(), out, err)
-                    .into();
-            bail!(err.chain_err(|| ErrorKind::AssertionFailed(self.cmd.clone())));
+            Err(AssertionError::new(AssertionKind::ExitCodeMismatch))
+                .context(KeyValueDisplay::new(
+                    "expected",
+                    self.expect_exit_code.expect("is_some already called"),
+                ))
+                .context(KeyValueDisplay::new(
+                    "got",
+                    output.status.code().unwrap_or_default(),
+                ))
+                .context(KeyValueDisplay::new("stdout", QuotedDisplay::new(out)))
+                .context(KeyValueDisplay::new("stderr", QuotedDisplay::new(err)))
+                .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))?;
         }
 
         self.expect_output
             .iter()
             .map(|a| {
                 a.verify(&output)
-                    .chain_err(|| ErrorKind::AssertionFailed(self.cmd.clone()))
+                    .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))
+                    .map_err(|e| failure::Error::from(e))
             })
             .collect::<Result<Vec<()>>>()?;
 
@@ -397,8 +414,16 @@ impl Assert {
     /// ```
     pub fn unwrap(self) {
         if let Err(err) = self.execute() {
-            panic!("{}", err.display_chain());
+            panic!(Self::format_causes(err.causes()));
+        }
+    }
+
+    fn format_causes(mut causes: failure::Causes) -> String {
+        let mut result = causes.next().expect("an error should exist").to_string();
+        for cause in causes {
+            result.push_str(&format!("\nwith: {}", cause));
         }
+        result
     }
 }
 

src/bin/assert_fixture.rs

@@ -1,17 +1,13 @@
-#[macro_use]
-extern crate error_chain;
+extern crate failure;
 
+use std::io;
+use std::io::Write;
 use std::env;
 use std::process;
 
-error_chain! {
-    foreign_links {
-        Env(env::VarError);
-        ParseInt(std::num::ParseIntError);
-    }
-}
+use failure::ResultExt;
 
-fn run() -> Result<()> {
+fn run() -> Result<(), failure::Error> {
     if let Ok(text) = env::var("stdout") {
         println!("{}", text);
     }
@@ -23,9 +19,18 @@ fn run() -> Result<()> {
         .ok()
         .map(|v| v.parse::<i32>())
         .map_or(Ok(None), |r| r.map(Some))
-        .chain_err(|| "Invalid exit code")?
+        .context("Invalid exit code")?
         .unwrap_or(0);
     process::exit(code);
 }
 
-quick_main!(run);
+fn main() {
+    let code = match run() {
+        Ok(_) => 0,
+        Err(ref e) => {
+            write!(&mut io::stderr(), "{}", e).expect("writing to stderr won't fail");
+            1
+        }
+    };
+    process::exit(code);
+}

src/diff.rs

@@ -1,8 +1,8 @@
-extern crate colored;
-use self::colored::Colorize;
-use difference::{Changeset, Difference};
 use std::fmt::{Error as fmtError, Write};
 
+use colored::Colorize;
+use difference::{Changeset, Difference};
+
 pub fn render(&Changeset { ref diffs, .. }: &Changeset) -> Result<String, fmtError> {
     let mut t = String::new();
 

src/errors.rs

@@ -1,67 +1,154 @@
-use output;
-use std::ffi::OsString;
-
-const ERROR_PREFIX: &'static str = "CLI assertion failed";
-
-fn format_cmd(cmd: &[OsString]) -> String {
-    let result: Vec<String> = cmd.iter()
-        .map(|s| s.to_string_lossy().into_owned())
-        .collect();
-    result.join(" ")
-}
-
-error_chain! {
-    links {
-        Output(output::Error, output::ErrorKind);
-    }
-    foreign_links {
-        Io(::std::io::Error);
-        Fmt(::std::fmt::Error);
-    }
-    errors {
-        SpawnFailed(cmd: Vec<OsString>) {
-            description("Spawn failed")
-            display(
-                "{}: (command `{}` failed to run)",
-                ERROR_PREFIX,
-                format_cmd(cmd),
-            )
-        }
-        AssertionFailed(cmd: Vec<OsString>) {
-            description("Assertion failed")
-            display(
-                "{}: (command `{}` failed)",
-                ERROR_PREFIX,
-                format_cmd(cmd),
-            )
-        }
-        StatusMismatch(expected: bool, out: String, err: String) {
-            description("Wrong status")
-            display(
-                "Expected to {}\nstatus={}\nstdout=```{}```\nstderr=```{}```",
-                expected = if *expected { "succeed" } else { "fail" },
-                got = if *expected { "failed" } else { "succeeded" },
-                out = out,
-                err = err,
-            )
-        }
-        ExitCodeMismatch(
-            expected: Option<i32>,
-            got: Option<i32>,
-            out: String,
-            err: String
-        ) {
-            description("Wrong exit code")
-            display(
-                "Expected exit code to be `{expected:?}`)\n\
-                exit code=`{code:?}`\n\
-                stdout=```{stdout}```\n\
-                stderr=```{stderr}```",
-                expected=expected,
-                code=got,
-                stdout=out,
-                stderr=err,
-            )
+use std::fmt;
+use std::result;
+
+use failure;
+
+pub type Result<T> = result::Result<T, failure::Error>;
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Fail)]
+pub enum AssertionKind {
+    #[fail(display = "Spawn failed.")] Spawn,
+    #[fail(display = "Status mismatch.")] StatusMismatch,
+    #[fail(display = "Exit code mismatch.")] ExitCodeMismatch,
+    #[fail(display = "Output mismatch.")] OutputMismatch,
+}
+
+#[derive(Debug)]
+pub struct AssertionError {
+    inner: failure::Context<AssertionKind>,
+}
+
+impl AssertionError {
+    pub fn new(kind: AssertionKind) -> Self {
+        Self { inner: kind.into() }
+    }
+
+    pub fn kind(&self) -> AssertionKind {
+        *self.inner.get_context()
+    }
+}
+
+impl failure::Fail for AssertionError {
+    fn cause(&self) -> Option<&failure::Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&failure::Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl fmt::Display for AssertionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(f, "CLI Assertion Error: {}", self.inner)
+    }
+}
+
+impl From<AssertionKind> for AssertionError {
+    fn from(kind: AssertionKind) -> AssertionError {
+        AssertionError {
+            inner: failure::Context::new(kind),
         }
     }
 }
+
+impl From<failure::Context<AssertionKind>> for AssertionError {
+    fn from(inner: failure::Context<AssertionKind>) -> AssertionError {
+        AssertionError { inner: inner }
+    }
+}
+
+#[derive(Debug)]
+pub struct KeyValueDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    key: &'static str,
+    context: D,
+}
+
+impl<D> KeyValueDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    pub fn new(key: &'static str, context: D) -> Self {
+        Self { key, context }
+    }
+
+    pub fn key(&self) -> &str {
+        self.key
+    }
+
+    pub fn context(&self) -> &D {
+        &self.context
+    }
+}
+
+impl<D> fmt::Display for KeyValueDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}={}", self.key, self.context)
+    }
+}
+
+#[derive(Debug)]
+pub struct DebugDisplay<D>
+where
+    D: fmt::Debug + Send + Sync + 'static,
+{
+    context: D,
+}
+
+impl<D> DebugDisplay<D>
+where
+    D: fmt::Debug + Send + Sync + 'static,
+{
+    pub fn new(context: D) -> Self {
+        Self { context }
+    }
+
+    pub fn context(&self) -> &D {
+        &self.context
+    }
+}
+
+impl<D> fmt::Display for DebugDisplay<D>
+where
+    D: fmt::Debug + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.context)
+    }
+}
+
+#[derive(Debug)]
+pub struct QuotedDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    context: D,
+}
+
+impl<D> QuotedDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    pub fn new(context: D) -> Self {
+        Self { context }
+    }
+
+    pub fn context(&self) -> &D {
+        &self.context
+    }
+}
+
+impl<D> fmt::Display for QuotedDisplay<D>
+where
+    D: fmt::Display + Send + Sync + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "```{}```", self.context)
+    }
+}

src/lib.rs

@@ -117,10 +117,12 @@
 
 #![deny(missing_docs)]
 
+extern crate colored;
 extern crate difference;
 extern crate environment;
+extern crate failure;
 #[macro_use]
-extern crate error_chain;
+extern crate failure_derive;
 extern crate serde_json;
 
 mod errors;