#![deny(
missing_docs,
missing_debug_implementations,
missing_copy_implementations,
trivial_casts,
trivial_numeric_casts,
unreachable_pub,
unsafe_code,
unstable_features,
unused_extern_crates,
unused_import_braces,
unused_qualifications,
variant_size_differences
)]
extern crate failure;
pub struct ExitFailure(failure::Error);
impl std::fmt::Debug for ExitFailure {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
use failure::Fail;
let mut fail: &Fail = self.0.cause();
write!(f, "{}", fail)?;
while let Some(cause) = fail.cause() {
write!(f, "\nInfo: caused by {}", cause)?;
fail = cause;
}
if let Ok(x) = std::env::var("RUST_BACKTRACE") {
if x == "1" {
write!(f, "\n{}", self.0.backtrace())?
}
}
Ok(())
}
}
impl<T: Into<failure::Error>> From<T> for ExitFailure {
fn from(t: T) -> Self {
ExitFailure(t.into())
}
}
pub struct ExitDisplay<E: std::fmt::Display>(E);
impl<E: std::fmt::Display> std::fmt::Debug for ExitDisplay<E> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl<E: std::fmt::Display> From<E> for ExitDisplay<E> {
fn from(e: E) -> Self {
ExitDisplay(e)
}
}
#[cfg(test)]
mod test {
use super::*;
use std::fmt::Write;
#[test]
fn test_exitfailure() {
let mut buffer = String::new();
let error = failure::err_msg("some failure").context("some context");
let exitfailure: ExitFailure = error.into();
write!(buffer, "{:?}", exitfailure).unwrap();
assert!(buffer.contains("some failure"));
assert!(buffer.contains("some context"));
}
#[test]
fn test_exitdisplay() {
let mut buffer = String::new();
let error = "some error".to_string();
let exitdisplay: ExitDisplay<String> = error.into();
write!(buffer, "{:?}", exitdisplay).unwrap();
assert_eq!(buffer, "some error");
}
}