Merge pull request #20 from panicbit/17-support-skip_if-attribute

17 support skip if attribute

Author: panicbit

README.md

@@ -2,9 +2,9 @@
 
 Derive `Debug` with a custom format per field.
 
-# Usage
+# Example usage
 
-Here is a showcase of all possible field attributes:
+Here is a showcase of `custom_debug`s features:
 
 ```rust
     use custom_debug::Debug;
@@ -16,8 +16,10 @@ Here is a showcase of all possible field attributes:
         x: i32,
         #[debug(skip)]
         y: i32,
-        #[debug(with = "hex_fmt")]
+        #[debug(with = hex_fmt)]
         z: i32,
+        #[debug(skip_if = Option::is_none)]
+        label: Option<String>,
     }
 
     fn hex_fmt<T: fmt::Debug>(n: &T, f: &mut fmt::Formatter) -> fmt::Result {
@@ -33,3 +35,21 @@ Foo {
     z: 0xAB
 }
 ```
+
+# Field attributes reference
+
+Attributes within a section below are considered mutually exclusive.
+
+## Skip attributes
+
+| | |
+|-|-|
+| `skip` | Unconditionally skips a field. |
+| `skip_if = path::to::function` | Skips a field if `path::to::function(&field)` returns `true`. |
+
+## Format attributes
+
+| | |
+|-|-|
+| `format = "format string {}"` | Formats a field using a format string. Must contain a placeholder (`{}`) with modifiers of your choice. |
+| `with = path::to::formatter` | Formats a field using `path::to::formatter`. The required signature is `fn(&T, &mut std::fmt::Formatter) -> std::fmt::Result` where `T` is a type compatible with the field's type (i.e. the function can be generic and coercions apply). |

custom_debug_derive/src/field_attributes.rs

@@ -1,42 +1,48 @@
-use std::cell::OnceCell;
-
 use darling::util::Flag;
 use darling::FromMeta;
 use syn::ExprPath;
 
 #[derive(Default)]
 pub struct FieldAttributes {
-    pub skip: bool,
+    pub skip_mode: SkipMode,
     pub debug_format: DebugFormat,
 }
 
 impl FieldAttributes {
     fn new(internal: InternalFieldAttributes) -> darling::Result<Self> {
-        let skip = internal.skip.is_present();
-        let debug_format = OnceCell::new();
+        let mut skip_mode = SkipMode::Default;
+        let mut debug_format = DebugFormat::Default;
+
+        if internal.skip.is_present() {
+            skip_mode = skip_mode.try_combine(SkipMode::Always)?;
+        }
+
+        if let Some(skip_if) = internal.skip_if {
+            skip_mode = skip_mode.try_combine(SkipMode::Condition(skip_if))?;
+        }
 
         if let Some(format) = internal.format {
-            debug_format
-                .set(DebugFormat::Format(format))
-                .map_err(|_| conflicting_format_options_error())?;
+            debug_format = debug_format.try_combine(DebugFormat::Format(format))?;
         }
 
         if let Some(with) = internal.with {
-            debug_format
-                .set(DebugFormat::With(with))
-                .map_err(|_| conflicting_format_options_error())?;
+            debug_format = debug_format.try_combine(DebugFormat::With(with))?;
         }
 
-        let debug_format = debug_format.into_inner().unwrap_or(DebugFormat::Default);
-
-        Ok(Self { skip, debug_format })
+        Ok(Self {
+            skip_mode,
+            debug_format,
+        })
     }
 
     pub fn try_combine(self, other: Self) -> darling::Result<Self> {
-        let skip = self.skip || other.skip;
+        let skip_mode = self.skip_mode.try_combine(other.skip_mode)?;
         let debug_format = self.debug_format.try_combine(other.debug_format)?;
 
-        Ok(Self { skip, debug_format })
+        Ok(Self {
+            skip_mode,
+            debug_format,
+        })
     }
 }
 
@@ -80,13 +86,36 @@ impl DebugFormat {
     }
 }
 
+#[derive(Default, PartialEq, Eq)]
+pub enum SkipMode {
+    #[default]
+    Default,
+    Condition(ExprPath),
+    Always,
+}
+
+impl SkipMode {
+    fn try_combine(self, other: Self) -> darling::Result<Self> {
+        match (&self, &other) {
+            (SkipMode::Default, _) => Ok(other),
+            (_, SkipMode::Default) => Ok(self),
+            _ => Err(conflicting_skip_options_error()),
+        }
+    }
+}
+
 #[derive(FromMeta)]
 struct InternalFieldAttributes {
     skip: Flag,
+    skip_if: Option<ExprPath>,
     format: Option<String>,
     with: Option<ExprPath>,
 }
 
+fn conflicting_skip_options_error() -> darling::Error {
+    darling::Error::custom("Conflicting skip options")
+}
+
 fn conflicting_format_options_error() -> darling::Error {
     darling::Error::custom("Conflicting format options")
 }

custom_debug_derive/src/lib.rs

@@ -4,13 +4,13 @@ use quote::quote;
 use syn::{Fields, Result};
 use synstructure::{decl_derive, AddBounds, BindingInfo, Structure, VariantInfo};
 
-use crate::field_attributes::{DebugFormat, FieldAttributes};
-use crate::filter_ext::RetainExt;
+use crate::field_attributes::{DebugFormat, FieldAttributes, SkipMode};
 use crate::result_into_stream_ext::ResultIntoStreamExt;
+use crate::retain_ext::RetainExt;
 
 mod field_attributes;
-mod filter_ext;
 mod result_into_stream_ext;
+mod retain_ext;
 #[cfg(test)]
 mod tests;
 
@@ -39,7 +39,7 @@ fn filter_out_skipped_fields(structure: &mut Structure) -> Result<()> {
     structure.try_retain(|binding| {
         let field_attributes = parse_field_attributes(binding)?;
 
-        Ok(!field_attributes.skip)
+        Ok(field_attributes.skip_mode != SkipMode::Always)
     })?;
 
     Ok(())
@@ -51,11 +51,27 @@ fn generate_match_arm_body(variant: &VariantInfo) -> Result<TokenStream> {
         Fields::Named(_) | Fields::Unit => quote! { debug_struct },
         Fields::Unnamed(_) => quote! { debug_tuple },
     };
-    let debug_builder_calls = variant
-        .bindings()
-        .iter()
-        .map(generate_debug_builder_call)
-        .collect::<Result<Vec<_>>>()?;
+    let mut debug_builder_calls = Vec::new();
+
+    for binding in variant.bindings() {
+        let field_attributes = parse_field_attributes(binding)?;
+
+        let debug_builder_call = match &field_attributes.skip_mode {
+            SkipMode::Default => generate_debug_builder_call(binding, &field_attributes)?,
+            SkipMode::Condition(condition) => {
+                let debug_builder_call = generate_debug_builder_call(binding, &field_attributes)?;
+
+                quote! {
+                    if (!#condition(#binding)) {
+                        #debug_builder_call
+                    }
+                }
+            }
+            SkipMode::Always => quote! {},
+        };
+
+        debug_builder_calls.push(debug_builder_call);
+    }
 
     Ok(quote! {
         let mut debug_builder = fmt.#debug_builder(#name);
@@ -66,8 +82,10 @@ fn generate_match_arm_body(variant: &VariantInfo) -> Result<TokenStream> {
     })
 }
 
-fn generate_debug_builder_call(binding: &BindingInfo) -> Result<TokenStream> {
-    let field_attributes = parse_field_attributes(binding)?;
+fn generate_debug_builder_call(
+    binding: &BindingInfo,
+    field_attributes: &FieldAttributes,
+) -> Result<TokenStream> {
     let format = generate_debug_impl(binding, &field_attributes.debug_format);
 
     let debug_builder_call =

custom_debug_derive/src/filter_ext.rs custom_debug_derive/src/retain_ext.rscustom_debug_derive/src/filter_ext.rs renamed to custom_debug_derive/src/retain_ext.rs

@@ -148,6 +148,45 @@ fn test_skip() {
     }
 }
 
+#[test]
+fn test_conditional_skip() {
+    test_derive! {
+        custom_debug_derive {
+            struct Point {
+                x: f32,
+                #[debug(skip_if = Option::is_none)]
+                y: Option<f32>,
+                z: f32,
+            }
+        }
+
+        expands to {
+            #[allow(non_upper_case_globals)]
+            const _DERIVE_core_fmt_Debug_FOR_Point: () = {
+                impl ::core::fmt::Debug for Point {
+                    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                        match self {
+                            Point { x: ref __binding_0, y: ref __binding_1, z: ref __binding_2, } => {
+                                let mut debug_builder = fmt.debug_struct("Point");
+                                debug_builder.field("x", __binding_0);
+
+                                if (!Option::is_none(__binding_1)) {
+                                    debug_builder.field("y", __binding_1);
+                                }
+
+                                debug_builder.field("z", __binding_2);
+                                debug_builder.finish()
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        no_build
+    }
+}
+
 #[test]
 fn test_enum() {
     test_derive! {

custom_debug_derive/src/tests.rs

@@ -0,0 +1,38 @@
+#![allow(clippy::disallowed_names)]
+use core::fmt;
+
+use custom_debug::Debug;
+
+#[derive(Debug)]
+struct Foo {
+    x: i32,
+    #[debug(
+        skip_if = Option::is_none,
+        with = strip_some,
+    )]
+    y: Option<i32>,
+    z: i32,
+}
+
+fn main() {
+    let mut foo = Foo {
+        x: 42,
+        y: None,
+        z: 171,
+    };
+
+    println!("With `y = None`:");
+    println!("{:#?}", foo);
+
+    foo.y = Some(123);
+    println!("With `y = Some(123)`:");
+    println!("{:#?}", foo);
+}
+
+fn strip_some<T: fmt::Debug>(value: &Option<T>, f: &mut fmt::Formatter) -> fmt::Result {
+    if let Some(value) = value {
+        value.fmt(f)?;
+    }
+
+    Ok(())
+}