Merge pull request killercup#26 from killercup/hide-them-enums

Hide enums

Author: killercup

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "convey"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Pascal Hertleif <[email protected]>"]
 description = "A Rust create for outputting information and log messages for humans and machines"
 license = "Apache-2.0 OR MIT"
@@ -25,5 +25,5 @@ crossbeam-channel = "0.2.6"
 proptest = "0.8.7"
 assert_fs = "0.9.0"
 predicates = "0.9.0"
-convey_derive = { version = "0.1", path = "convey_derive" }
+convey_derive = { version = "0.2", path = "convey_derive" }
 rand = "0.5.5"

convey_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "convey_derive"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Katharina Fey <[email protected]>", "Pascal Hertleif <[email protected]>"]
 description = "A Rust create for outputting information and log messages for humans and machines"
 license = "Apache-2.0 OR MIT"
@@ -14,6 +14,6 @@ syn = "0.15"
 quote = "0.6"
 
 [dev-dependencies]
-convey = { version = "0.1", path = ".." }
+convey = { version = "0.2", path = ".." }
 serde = "1.0.79"
 serde_derive = "1.0.79"

src/error.rs

@@ -1,41 +1,84 @@
+use failure::{Backtrace, Context, Fail};
 use serde_json::Error as JsonError;
+use std::fmt::{self, Display};
 use std::io;
+use std::sync::PoisonError;
 use termcolor::ParseColorError;
 
+#[derive(Debug)]
 /// Output's error type
+pub struct Error {
+    inner: Context<InnerError>,
+}
+
+impl Fail for Error {
+    fn cause(&self) -> Option<&Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
 #[derive(Fail, Debug)]
-pub enum Error {
-    /// I/O Error
+enum InnerError {
     #[fail(display = "IO error: {}", _0)]
     Io(io::Error),
-    /// Error parsing a color value
+
     #[fail(display = "{}", _0)]
     ParseColorError(ParseColorError),
-    /// Error dealing with JSON
-    #[fail(display = "{}", _0)]
+
+    #[fail(display = "Json error: {}", _0)]
     Json(JsonError),
-    /// Error in formatting worker
-    #[fail(display = "{}", _0)]
+
+    #[fail(display = "Worker error: {}", _0)]
     WorkerError(String),
-    /// Error syncing output
+
     #[fail(display = "Error syncing output")]
-    SyncError,
+    SyncError(String),
+}
+
+impl Error {
+    pub(crate) fn worker_error(x: String) -> Self {
+        Error {
+            inner: Context::new(InnerError::WorkerError(x)),
+        }
+    }
+
+    pub(crate) fn sync_error<T>(x: &PoisonError<T>) -> Self {
+        Error {
+            inner: Context::new(InnerError::SyncError(x.to_string())),
+        }
+    }
 }
 
 impl From<io::Error> for Error {
     fn from(x: io::Error) -> Self {
-        Error::Io(x)
+        Error {
+            inner: Context::new(InnerError::Io(x)),
+        }
     }
 }
 
 impl From<ParseColorError> for Error {
     fn from(x: ParseColorError) -> Self {
-        Error::ParseColorError(x)
+        Error {
+            inner: Context::new(InnerError::ParseColorError(x)),
+        }
     }
 }
 
 impl From<JsonError> for Error {
     fn from(x: JsonError) -> Self {
-        Error::Json(x)
+        Error {
+            inner: Context::new(InnerError::Json(x)),
+        }
     }
 }

src/human.rs

@@ -1,14 +1,13 @@
 //! Human output
 
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use termcolor::{ColorChoice, ColorSpec, StandardStream, WriteColor};
 use {Error, Target};
 
 /// Construct a new human output target that writes to stdout
 pub fn stdout() -> Result<Target, Error> {
-    Ok(Target::Human(Arc::new(Mutex::new(Formatter::init_with(
-        || Ok(StandardStream::stdout(ColorChoice::Auto)),
-    )?))))
+    let formatter = Formatter::init_with(|| Ok(StandardStream::stdout(ColorChoice::Auto)))?;
+    Ok(Target::human(formatter))
 }
 
 pub use self::test_helper::{test, test_with_color};
@@ -52,7 +51,7 @@ impl Formatter {
 
         match self.inner.receiver.recv() {
             Some(Response::Flushed) => Ok(()),
-            msg => Err(Error::WorkerError(format!("unexpected message {:?}", msg))),
+            msg => Err(Error::worker_error(format!("unexpected message {:?}", msg))),
         }
     }
 
@@ -131,7 +130,7 @@ impl InternalFormatter {
                 sender: message_sender,
                 receiver: response_receiver,
             }),
-            msg => Err(Error::WorkerError(format!("unexpected message {:?}", msg))),
+            msg => Err(Error::worker_error(format!("unexpected message {:?}", msg))),
         }
     }
 }
@@ -215,7 +214,6 @@ macro_rules! render_for_humans {
 
 mod test_helper {
     use super::Formatter;
-    use std::sync::{Arc, Mutex};
     use termcolor::Buffer;
     use {test_buffer::TestBuffer, Target};
 
@@ -268,7 +266,7 @@ mod test_helper {
         }
 
         pub fn target(&self) -> Target {
-            Target::Human(Arc::new(Mutex::new(self.formatter())))
+            Target::human(self.formatter())
         }
 
         pub fn to_string(&self) -> String {

src/json.rs

@@ -4,29 +4,29 @@ use serde::Serialize;
 use serde_json::to_vec as write_json;
 use std::io::Write;
 use std::path::Path;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use {Error, Target};
 
 /// Create a new JSON output that writes to a file
 pub fn file<T: AsRef<Path>>(name: T) -> Result<Target, Error> {
     let path = name.as_ref().to_path_buf();
-    Ok(Target::Json(Arc::new(Mutex::new(Formatter::init_with(
-        move || {
-            use std::fs::{File, OpenOptions};
-            use std::io::BufWriter;
-
-            let target = if path.exists() {
-                let mut f = OpenOptions::new().write(true).append(true).open(&path)?;
-                f.write_all(b"\n")?;
-
-                f
-            } else {
-                File::create(&path)?
-            };
+    let formatter = Formatter::init_with(move || {
+        use std::fs::{File, OpenOptions};
+        use std::io::BufWriter;
+
+        let target = if path.exists() {
+            let mut f = OpenOptions::new().write(true).append(true).open(&path)?;
+            f.write_all(b"\n")?;
+
+            f
+        } else {
+            File::create(&path)?
+        };
+
+        Ok(BufWriter::new(target))
+    })?;
 
-            Ok(BufWriter::new(target))
-        },
-    )?))))
+    Ok(Target::json(formatter))
 }
 
 pub use self::test_helper::test;
@@ -58,7 +58,7 @@ impl Formatter {
 
         match self.inner.receiver.recv() {
             Some(Response::Flushed) => Ok(()),
-            msg => Err(Error::WorkerError(format!("unexpected message {:?}", msg))),
+            msg => Err(Error::worker_error(format!("unexpected message {:?}", msg))),
         }
     }
 
@@ -137,7 +137,7 @@ impl InternalFormatter {
                 sender: message_sender,
                 receiver: response_receiver,
             }),
-            msg => Err(Error::WorkerError(format!("unexpected message {:?}", msg))),
+            msg => Err(Error::worker_error(format!("unexpected message {:?}", msg))),
         }
     }
 }
@@ -207,7 +207,6 @@ macro_rules! render_json {
 
 mod test_helper {
     use super::Formatter;
-    use std::sync::{Arc, Mutex};
     use termcolor::Buffer;
     use test_buffer::TestBuffer;
     use Target;
@@ -264,7 +263,7 @@ mod test_helper {
         }
 
         pub fn target(&self) -> Target {
-            Target::Json(Arc::new(Mutex::new(self.formatter())))
+            Target::json(self.formatter())
         }
 
         pub fn to_string(&self) -> String {

src/lib.rs

@@ -61,14 +61,33 @@ use std::sync::{Arc, Mutex};
 
 /// Known targets to write to
 #[derive(Clone)]
-pub enum Target {
+pub struct Target {
+    inner: InnerTarget,
+}
+
+impl Target {
     /// Human readable output
     ///
     /// Will mostly be (unstructured) text, optionally with formatting.
-    Human(Arc<Mutex<human::Formatter>>),
+    pub(crate) fn human(f: human::Formatter) -> Self {
+        Target {
+            inner: InnerTarget::Human(Arc::new(Mutex::new(f))),
+        }
+    }
+
     /// JSON output
     ///
     /// Machines like this.
+    pub(crate) fn json(f: json::Formatter) -> Self {
+        Target {
+            inner: InnerTarget::Json(Arc::new(Mutex::new(f))),
+        }
+    }
+}
+
+#[derive(Clone)]
+enum InnerTarget {
+    Human(Arc<Mutex<human::Formatter>>),
     Json(Arc<Mutex<json::Formatter>>),
 }
 
@@ -79,14 +98,14 @@ impl Output {
     /// Print some item to the currently active output targets
     pub fn print<O: Render>(&mut self, item: O) -> Result<(), Error> {
         for target in &mut self.targets {
-            match target {
-                Target::Human(fmt) => {
-                    let mut fmt = fmt.lock().map_err(|_| Error::SyncError)?;
+            match &target.inner {
+                InnerTarget::Human(fmt) => {
+                    let mut fmt = fmt.lock().map_err(|e| Error::sync_error(&e))?;
                     item.render_for_humans(&mut *fmt)?;
                     fmt.write("\n")?;
                 }
-                Target::Json(fmt) => {
-                    let mut fmt = fmt.lock().map_err(|_| Error::SyncError)?;
+                InnerTarget::Json(fmt) => {
+                    let mut fmt = fmt.lock().map_err(|e| Error::sync_error(&e))?;
                     item.render_json(&mut *fmt)?;
                     fmt.write_separator()?;
                 }
@@ -99,13 +118,13 @@ impl Output {
     /// Immediately write all buffered output
     pub fn flush(&self) -> Result<(), Error> {
         for target in &self.targets {
-            match target {
-                Target::Human(fmt) => {
-                    let mut fmt = fmt.lock().map_err(|_| Error::SyncError)?;
+            match &target.inner {
+                InnerTarget::Human(fmt) => {
+                    let mut fmt = fmt.lock().map_err(|e| Error::sync_error(&e))?;
                     fmt.flush()?;
                 }
-                Target::Json(fmt) => {
-                    let mut fmt = fmt.lock().map_err(|_| Error::SyncError)?;
+                InnerTarget::Json(fmt) => {
+                    let mut fmt = fmt.lock().map_err(|e| Error::sync_error(&e))?;
                     fmt.flush()?;
                 }
             }