Add 'skip' field attribute

Author: panicbit

README.md

@@ -4,28 +4,32 @@ Derive `Debug` with a custom format per field.
 
 # Usage
 
+Here is a showcase of all possible field attributes:
+
 ```rust
     #[macro_use] extern crate custom_debug_derive;
     use std::fmt;
 
     #[derive(CustomDebug)]
     struct Foo {
         #[debug(format = "{} things")]
-        n: i32,
+        x: f32,
+        #[debug(skip)]
+        y: f32,
         #[debug(with = "hex_fmt")]
-        m: i32,
+        z: f32,
     }
 
     fn hex_fmt<T: fmt::Debug>(n: &T, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "0x{:02X?}", n)
     }
 ```
 
-Would print something like
+The resulting debug output would look something like this:
 
 ```
 Foo {
-    n: 42 things,
-    m: 0xAB
+    x: 42 things,
+    z: 0xAB
 }
 ```

src/lib.rs

@@ -4,13 +4,14 @@ extern crate syn;
 
 use proc_macro2::TokenStream;
 use synstructure::Structure;
-use syn::{Fields, Meta, NestedMeta, Lit, Path, parse_str};
+use syn::{Fields, Meta, NestedMeta, Lit, Path, Ident, parse_str};
 
 decl_derive!([CustomDebug, attributes(debug)] => custom_debug_derive);
 
 fn custom_debug_derive(s: Structure) -> TokenStream {
     let name = s.ast().ident.to_string();
-    let debug_attr = parse_str("debug").unwrap();
+    let debug_attr = parse_str::<Path>("debug").unwrap();
+    let skip_ident = parse_str::<Ident>("skip").unwrap();
 
     let variants = s.each_variant(|variant| {
         let debug_helper = match variant.ast().fields {
@@ -22,48 +23,52 @@ fn custom_debug_derive(s: Structure) -> TokenStream {
         let variant_body = variant.bindings().iter().map(|b| {
             let mut format = None;
 
-            b.ast().attrs.iter()
+            let metas = b.ast().attrs.iter()
             .filter(|attr| attr.path == debug_attr)
             .flat_map(|attr| attr.interpret_meta())
             .flat_map(|meta| match meta {
                 Meta::List(list) => list.nested,
                 _ => panic!("Invalid debug attribute"),
-            })
-            .for_each(|meta| match meta {
-                NestedMeta::Meta(Meta::NameValue(nv)) => {
-                    let value = nv.lit;
-                    format = Some(match &*nv.ident.to_string() {
-                        "format" => quote! { &format_args!(#value, #b) },
-                        "with" => match value {
-                            Lit::Str(fun) => {
-                                let fun = fun.parse::<Path>().unwrap();
-                                quote! {
-                                    &{
-                                        struct DebugWith<'a, T: 'a> {
-                                            data: &'a T,
-                                            fmt: fn(&T, &mut ::std::fmt::Formatter) -> ::std::fmt::Result,
-                                        }
+            });
 
-                                        impl<'a, T: 'a> ::std::fmt::Debug for DebugWith<'a, T> {
-                                            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                                                (self.fmt)(self.data, f)
+            for meta in metas {
+                match meta {
+                    NestedMeta::Meta(Meta::Word(ref ident)) if ident == &skip_ident => return quote! {},
+                    NestedMeta::Meta(Meta::NameValue(nv)) => {
+                        let value = nv.lit;
+                        format = Some(match &*nv.ident.to_string() {
+                            "format" => quote! { &format_args!(#value, #b) },
+                            "with" => match value {
+                                Lit::Str(fun) => {
+                                    let fun = fun.parse::<Path>().unwrap();
+                                    quote! {
+                                        &{
+                                            struct DebugWith<'a, T: 'a> {
+                                                data: &'a T,
+                                                fmt: fn(&T, &mut ::std::fmt::Formatter) -> ::std::fmt::Result,
+                                            }
+
+                                            impl<'a, T: 'a> ::std::fmt::Debug for DebugWith<'a, T> {
+                                                fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                                                    (self.fmt)(self.data, f)
+                                                }
                                             }
-                                        }
 
-                                        DebugWith {
-                                            data: #b,
-                                            fmt: #fun,
+                                            DebugWith {
+                                                data: #b,
+                                                fmt: #fun,
+                                            }
                                         }
                                     }
-                                }
+                                },
+                                _ => panic!("Invalid 'with' value"),
                             },
-                            _ => panic!("Invalid 'with' value"),
-                        },
-                        name => panic!("Unknown key '{}'", name),
-                    })
-                },
-                _ => panic!("Invalid debug attribute"),
-            });
+                            name => panic!("Unknown key '{}'", name),
+                        })
+                    },
+                    _ => panic!("Invalid debug attribute"),
+                }
+            }
 
             let format = format.unwrap_or_else(|| quote! { #b });
 
@@ -208,6 +213,39 @@ fn test_with() {
     }
 }
 
+#[test]
+fn test_skip() {
+    test_derive! {
+        custom_debug_derive {
+            struct Point {
+                x: f32,
+                #[debug(skip)]
+                y: f32,
+                z: f32,
+            }
+        }
+
+        expands to {
+            #[allow(non_upper_case_globals)]
+            const _DERIVE_std_fmt_Debug_FOR_Point: () = {
+                impl ::std::fmt::Debug for Point {
+                    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                        match self {
+                            Point { x: ref __binding_0, y: ref __binding_1, z: ref __binding_2, } => {
+                                let mut s = f.debug_struct("Point");
+                                s.field("x", __binding_0);
+                                s.field("z", __binding_2);
+                                s.finish()
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        no_build
+    }
+}
 
 #[test]
 fn test_enum() {