Derive tuple structs and add a test

Author: killercup

output_derive/Cargo.toml

@@ -10,3 +10,8 @@ proc-macro = true
 syn = "0.15"
 quote = "0.6"
 proc-macro2 = "0.4"
+
+[dev-dependencies]
+output = { version = "0.1", path = ".." }
+serde = "1.0.79"
+serde_derive = "1.0.79"

output_derive/src/lib.rs

@@ -16,38 +16,55 @@ pub fn render_output(input: TokenStream) -> TokenStream {
     let ast: DeriveInput = parse_macro_input!(input as DeriveInput);
 
     let name = &ast.ident;
-    let fields: Vec<_> = match ast.data {
+    let render_span = match ast.data {
         Data::Struct(s) => match s.fields {
-            Fields::Named(..) => s
-                .fields
-                .iter()
-                .map(|x| {
-                    let x = x.ident.clone().unwrap();
-                    (x.to_string(), quote!(#x))
-                }).collect(),
-            Fields::Unnamed(..) => s
-                .fields
-                .iter()
-                .enumerate()
-                .map(|(i, _)| (i.to_string(), quote!(#i)))
-                .collect(),
+            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 names = fields.iter().map(|(name, _)| name);
-    let fields = fields.iter().map(|(_, ident)| ident);
     let exp = quote! {
         impl output::Render for #name {
             fn render_for_humans(&self, fmt: &mut output::human::Formatter) -> Result<(), output::Error> {
-                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)?;
+                #render_span
                 Ok(())
             }
 

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(())
+}