Merge pull request killercup#15 from spacekookie/master

Adding custom derives for `Render`

Author: killercup

.travis.yml

@@ -9,7 +9,7 @@ matrix:
   - rust: 1.29.1
     env: CLIPPY=YESPLEASE
     before_script: rustup component add clippy-preview
-    script: cargo clippy --all-targets -- -D warnings
+    script: cargo clippy --all-targets --all -- -D warnings
   - rust: 1.29.1
     env: RUSTFMT=YESPLEASE
     before_script: rustup component add rustfmt-preview

Cargo.toml

@@ -7,6 +7,11 @@ license = "Apache-2.0 OR MIT"
 readme = "README.md"
 repository = "https://github.com/killercup/output-rs"
 
+[workspace]
+members = [
+    "output_derive"
+]
+
 [dependencies]
 termcolor = "1.0.4"
 serde = "1.0.79"
@@ -19,3 +24,4 @@ serde_derive = "1.0.79"
 proptest = "0.8.7"
 assert_fs = "0.9.0"
 predicates = "0.9.0"
+output_derive = { version = "0.1", path = "output_derive" }

examples/derive.rs

@@ -0,0 +1,35 @@
+extern crate failure;
+extern crate output;
+#[macro_use]
+extern crate output_derive;
+#[macro_use]
+extern crate serde_derive;
+
+use output::{human, json};
+
+fn main() -> Result<(), failure::Error> {
+    let mut out = output::new()
+        .add_target(json::file("target/foo.log")?)
+        .add_target(human::stdout()?);
+
+    #[derive(Serialize, RenderOutput)]
+    struct ErrorMessage {
+        code: i32,
+        name: String,
+        message: String,
+    }
+
+    out.print(&ErrorMessage {
+        code: 42,
+        name: String::from("info"),
+        message: String::from("Derive works"),
+    })?;
+
+    out.print(&ErrorMessage {
+        code: 0,
+        name: String::from("okay"),
+        message: String::from("Thanks for stopping by"),
+    })?;
+
+    Ok(())
+}

output_derive/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "output_derive"
+version = "0.1.0"
+authors = ["Katharina Fey <[email protected]>"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "0.15"
+quote = "0.6"
+
+[dev-dependencies]
+output = { version = "0.1", path = ".." }
+serde = "1.0.79"
+serde_derive = "1.0.79"

output_derive/src/lib.rs

@@ -0,0 +1,104 @@
+//! Custom derives for `output.rs`
+//!
+//! # Examples
+//!
+//! ```rust
+//! extern crate output;
+//! #[macro_use] extern crate output_derive;
+//! #[macro_use] extern crate serde_derive;
+//!
+//! #[derive(Serialize, RenderOutput)]
+//! struct Message {
+//!     code: i32,
+//!     message: String,
+//! }
+//!
+//! # fn main() -> Result<(), output::Error> {
+//! # use output::human;
+//! # let test_target = human::test();
+//! let mut out = output::new().add_target(test_target.target());
+//! out.print(&Message {
+//!     code: 42,
+//!     message: String::from("Derive works"),
+//! })?;
+//! # assert_eq!(test_target.to_string(), "code: 42\nmessage: Derive works\n\n");
+//! # Ok(()) }
+//! ```
+
+#![recursion_limit = "1024"]
+
+extern crate proc_macro;
+#[macro_use]
+extern crate quote;
+#[macro_use]
+extern crate syn;
+
+use proc_macro::TokenStream;
+use syn::{Data, DeriveInput, Fields};
+
+#[proc_macro_derive(RenderOutput)]
+pub fn render_output(input: TokenStream) -> TokenStream {
+    let ast: DeriveInput = parse_macro_input!(input as DeriveInput);
+
+    let name = &ast.ident;
+    let render_span = match ast.data {
+        Data::Struct(s) => match s.fields {
+            Fields::Named(..) => {
+                let fields = s.fields.iter().map(|f| {
+                    let x = f.ident.clone().unwrap();
+                    quote!(#x)
+                });
+                let names = s
+                    .fields
+                    .iter()
+                    .map(|f| f.ident.clone().unwrap().to_string());
+                quote! {
+                    let mut span = output::components::span();
+                    #(
+                        span = span.add_item(#names);
+                        span = span.add_item(": ");
+                        span = span.add_item(output::components::text(&self.#fields.to_string()));
+                        span = span.add_item("\n");
+                    )*
+                    span.render_for_humans(fmt)?;
+                }
+            }
+            Fields::Unnamed(..) => {
+                let field_count = s.fields.iter().count();
+                let fields = (0..field_count)
+                        .fold(Vec::new(), |mut res, i| {
+                            res.push(quote! { span = span.add_item(output::components::text(&self.#i.to_string())); });
+                            if i < field_count - 1 {
+                                res.push(quote! { span = span.add_item(", "); });
+                            }
+                            res
+                        });
+
+                quote! {
+                    let mut span = output::components::span();
+                    span = span.add_item("(");
+                    #(#fields)*
+                    span = span.add_item(")");
+                    span.render_for_humans(fmt)?;
+                }
+            }
+            _ => panic!("Unit structs not supported for now, sorry."),
+        },
+        _ => panic!("Only structs supported for now, sorry."),
+    };
+    let exp = quote! {
+        impl output::Render for #name {
+            fn render_for_humans(&self, fmt: &mut output::human::Formatter) -> Result<(), output::Error> {
+                #render_span
+                Ok(())
+            }
+
+            fn render_json(&self, fmt: &mut output::json::Formatter) -> Result<(), output::Error> {
+                fmt.write(self)?;
+                Ok(())
+            }
+        }
+    };
+
+    TokenStream::from(exp)
+}

output_derive/tests/structs.rs

@@ -0,0 +1,61 @@
+extern crate output;
+#[macro_use]
+extern crate output_derive;
+#[macro_use]
+extern crate serde_derive;
+
+#[test]
+fn struct_with_named_fields_of_primitive_types() -> Result<(), output::Error> {
+    #[derive(Serialize, RenderOutput)]
+    struct ErrorMessage {
+        code: i32,
+        name: String,
+        message: String,
+    }
+
+    let human = output::human::test();
+    let json = output::json::test();
+    let mut out = output::new()
+        .add_target(human.target())
+        .add_target(json.target());
+
+    out.print(&ErrorMessage {
+        code: 42,
+        name: String::from("info"),
+        message: String::from("Derive works"),
+    })?;
+
+    assert_eq!(
+        human.to_string(),
+        "code: 42\n\
+         name: info\n\
+         message: Derive works\n\n"
+    );
+
+    assert_eq!(
+        json.to_string(),
+        "{\"code\":42,\"name\":\"info\",\"message\":\"Derive works\"}\n\n"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn tuple_struct_of_primitive_types() -> Result<(), output::Error> {
+    #[derive(Serialize, RenderOutput)]
+    struct ErrorMessage(i32, String);
+
+    let human = output::human::test();
+    let json = output::json::test();
+    let mut out = output::new()
+        .add_target(human.target())
+        .add_target(json.target());
+
+    out.print(&ErrorMessage(42, String::from("Derive works")))?;
+
+    assert_eq!(human.to_string(), "(42, Derive works)\n");
+
+    assert_eq!(json.to_string(), "[42,\"Derive works\"]\n\n");
+
+    Ok(())
+}