Merge pull request killercup#18 from killercup/fearless-syncing-in-la-salida

WIP: Make this work in a concurrent setting

Author: killercup

Cargo.toml

@@ -19,9 +19,11 @@ serde_json = "1.0.31"
 failure_derive = "0.1.2"
 failure = "0.1.2"
 serde_derive = "1.0.79"
+crossbeam-channel = "0.2.6"
 
 [dev-dependencies]
 proptest = "0.8.7"
 assert_fs = "0.9.0"
 predicates = "0.9.0"
 output_derive = { version = "0.1", path = "output_derive" }
+rand = "0.5.5"

examples/concurrent.rs

@@ -0,0 +1,37 @@
+extern crate failure;
+extern crate output;
+extern crate rand;
+
+use output::{human, json};
+use rand::distributions::Distribution;
+use rand::distributions::Range;
+use rand::thread_rng;
+use std::thread;
+use std::time::Duration;
+
+fn main() -> Result<(), failure::Error> {
+    let out = output::new()
+        .add_target(json::file("target/foo.log")?)
+        .add_target(human::stdout()?);
+
+    let mut threads = vec![];
+    for i in 0..100 {
+        let mut out = out.clone();
+        let t = thread::spawn(move || {
+            let dur = Duration::from_millis({
+                let mut rng = thread_rng();
+                let range = Range::new(0u64, 1);
+                range.sample(&mut rng)
+            });
+            thread::sleep(dur);
+            out.print(&format!("thread {} says hello", i))
+        });
+        threads.push(t);
+    }
+
+    threads.into_iter().for_each(|t| {
+        t.join().unwrap().unwrap();
+    });
+
+    Ok(())
+}

output_derive/src/lib.rs

@@ -21,6 +21,7 @@
 //!     code: 42,
 //!     message: String::from("Derive works"),
 //! })?;
+//! # out.flush()?;
 //! # assert_eq!(test_target.to_string(), "code: 42\nmessage: Derive works\n\n");
 //! # Ok(()) }
 //! ```

output_derive/tests/structs.rs

@@ -24,6 +24,7 @@ fn struct_with_named_fields_of_primitive_types() -> Result<(), output::Error> {
         name: String::from("info"),
         message: String::from("Derive works"),
     })?;
+    out.flush()?;
 
     assert_eq!(
         human.to_string(),
@@ -34,7 +35,7 @@ fn struct_with_named_fields_of_primitive_types() -> Result<(), output::Error> {
 
     assert_eq!(
         json.to_string(),
-        "{\"code\":42,\"name\":\"info\",\"message\":\"Derive works\"}\n\n"
+        "{\"code\":42,\"name\":\"info\",\"message\":\"Derive works\"}\n"
     );
 
     Ok(())
@@ -52,10 +53,11 @@ fn tuple_struct_of_primitive_types() -> Result<(), output::Error> {
         .add_target(json.target());
 
     out.print(&ErrorMessage(42, String::from("Derive works")))?;
+    out.flush()?;
 
     assert_eq!(human.to_string(), "(42, Derive works)\n");
 
-    assert_eq!(json.to_string(), "[42,\"Derive works\"]\n\n");
+    assert_eq!(json.to_string(), "[42,\"Derive works\"]\n");
 
     Ok(())
 }

src/components/span.rs

@@ -1,4 +1,4 @@
-use termcolor::{ColorSpec, WriteColor};
+use termcolor::ColorSpec;
 use {human, json, Error, Render};
 
 /// Construct a new, empty span
@@ -96,7 +96,7 @@ impl Span {
 
 impl Render for Span {
     fn render_for_humans(&self, fmt: &mut human::Formatter) -> Result<(), Error> {
-        fmt.writer.set_color(
+        fmt.set_color(
             ColorSpec::new()
                 .set_fg(self.fg)
                 .set_bg(self.bg)
@@ -107,13 +107,17 @@ impl Render for Span {
         for item in &self.items {
             item.render_for_humans(fmt)?;
         }
-        fmt.writer.reset()?;
+        fmt.reset()?;
         Ok(())
     }
 
     fn render_json(&self, fmt: &mut json::Formatter) -> Result<(), Error> {
-        for item in &self.items {
-            item.render_json(fmt)?;
+        let len = self.items.len();
+        for i in 0..len {
+            self.items[i].render_json(fmt)?;
+            if i < len - 1 {
+                fmt.write_separator()?;
+            }
         }
         Ok(())
     }
@@ -138,15 +142,18 @@ mod test {
 
         let json = json::test();
         item.render_json(&mut json.formatter())?;
-        assert_eq!(json.to_string(), "\"one\"\n\"two\"\n\"three\"\n");
+        assert_eq!(json.to_string(), "\"one\"\n\"two\"\n\"three\"");
         Ok(())
     }
 
     #[test]
     fn test_colored_output() -> Result<(), Error> {
         let test_target = human::test_with_color();
         let mut out = ::new().add_target(test_target.target());
+
         out.print(span().add_item("hello").fg("green")?.bg("blue")?)?;
+        out.flush()?;
+
         assert_eq!(
             test_target.to_string(),
             "\u{1b}[0m\u{1b}[32m\u{1b}[44mhello\u{1b}[0m\n"
@@ -158,7 +165,10 @@ mod test {
     fn test_bold_output() -> Result<(), Error> {
         let test_target = human::test_with_color();
         let mut out = ::new().add_target(test_target.target());
+
         out.print(span().add_item("hello").bold(true)?)?;
+        out.flush()?;
+
         assert_eq!(
             test_target.to_string(),
             "\u{1b}[0m\u{1b}[1mhello\u{1b}[0m\n"
@@ -170,7 +180,10 @@ mod test {
     fn test_intense_output() -> Result<(), Error> {
         let test_target = human::test_with_color();
         let mut out = ::new().add_target(test_target.target());
+
         out.print(span().add_item("hello").fg("green")?.intense(true)?)?;
+        out.flush()?;
+
         assert_eq!(
             test_target.to_string(),
             "\u{1b}[0m\u{1b}[38;5;10mhello\u{1b}[0m\n"
@@ -182,7 +195,10 @@ mod test {
     fn test_underline_output() -> Result<(), Error> {
         let test_target = human::test_with_color();
         let mut out = ::new().add_target(test_target.target());
+
         out.print(span().add_item("hello").underline(true)?)?;
+        out.flush()?;
+
         assert_eq!(
             test_target.to_string(),
             "\u{1b}[0m\u{1b}[4mhello\u{1b}[0m\n"

src/components/text.rs

@@ -1,4 +1,3 @@
-use std::io::Write;
 use {human, json, Error, Render};
 
 /// Render some text
@@ -18,7 +17,7 @@ pub struct Text(String);
 
 impl Render for Text {
     fn render_for_humans(&self, fmt: &mut human::Formatter) -> Result<(), Error> {
-        fmt.writer.write_all(self.0.as_bytes())?;
+        fmt.write(self.0.as_bytes())?;
         Ok(())
     }
 
@@ -44,7 +43,7 @@ mod test {
 
             let json = json::test();
             item.render_json(&mut json.formatter()).unwrap();
-            prop_assert_eq!(json.to_string(), json!(s).to_string() + "\n");
+            prop_assert_eq!(json.to_string(), json!(s).to_string());
         }
     }
 }

src/error.rs

@@ -14,6 +14,12 @@ pub enum Error {
     /// Error dealing with JSON
     #[fail(display = "{}", _0)]
     Json(JsonError),
+    /// Error in formatting worker
+    #[fail(display = "{}", _0)]
+    WorkerError(String),
+    /// Error syncing output
+    #[fail(display = "Error syncing output")]
+    SyncError,
 }
 
 impl From<io::Error> for Error {