add op feature for filler

Author: yanganto

README.md

@@ -131,8 +131,8 @@ The [examples][examples] demo following scenarios.
 ## Features
 This crate also includes the following optional features:
 - `status`(default): implements the `Status` trait for the patch struct, which provides the `is_empty` method.
-- `op` (default): provide operators `<<` between instance and patch, and `+` for patches
-  - default: when there is a field conflict between patches, `+` will add together if the `#[patch(addable)]` or `#[patch(add=fn)]` is provided, else it will panic.
+- `op` (default): provide operators `<<` between instance and patch/filler, and `+` for patches/fillers
+  - default: when there is a field conflict between patches/fillers, `+` will add together if the `#[patch(addable)]`, `#[patch(add=fn)]` or `#[filler(addable)]` is provided, else it will panic.
 - `merge` (optional): implements the `Merge` trait for the patch struct, which provides the `merge` method, and `<<` (if `op` feature enabled) between patches.
 - `std`(optional):
   - `box`: implements the `Patch<Box<P>>` trait for `T` where `T` implements `Patch<P>`.

struct-patch-derive/src/filler.rs

@@ -5,10 +5,14 @@ use syn::meta::ParseNestedMeta;
 use syn::spanned::Spanned;
 use syn::{parenthesized, DeriveInput, Error, Lit, LitStr, Result, Type};
 
+#[cfg(feature = "op")]
+use crate::Addable;
+
 const FILLER: &str = "filler";
 const ATTRIBUTE: &str = "attribute";
 const EXTENDABLE: &str = "extendable";
 const EMPTY_VALUE: &str = "empty_value";
+const ADDABLE: &str = "addable";
 
 pub(crate) struct Filler {
     visibility: syn::Visibility,
@@ -49,6 +53,8 @@ struct Field {
     ty: Type,
     attributes: Vec<TokenStream>,
     fty: FillerType,
+    #[cfg(feature = "op")]
+    addable: Addable,
 }
 
 impl Filler {
@@ -74,6 +80,13 @@ impl Filler {
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
 
+        #[cfg(feature = "op")]
+        let option_field_names_addable = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::Option))
+            .map(|f| !matches!(f.addable, Addable::Disable))
+            .collect::<Vec<_>>();
+
         let extendable_field_names = fields
             .iter()
             .filter(|f| matches!(f.fty, FillerType::Extendable(_)))
@@ -86,18 +99,32 @@ impl Filler {
             .map(|f| f.fty.inner())
             .collect::<Vec<_>>();
 
+        #[cfg(feature = "op")]
+        let extendable_field_addable = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::Extendable(_)))
+            .map(|f| !matches!(f.addable, Addable::Disable))
+            .collect::<Vec<_>>();
+
         let native_value_field_names = fields
             .iter()
             .filter(|f| matches!(f.fty, FillerType::NativeValue(_)))
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
 
-        let native_value_field_values = fields
+        let native_value_field_empty_values = fields
             .iter()
             .filter(|f| matches!(f.fty, FillerType::NativeValue(_)))
             .map(|f| f.fty.value())
             .collect::<Vec<_>>();
 
+        #[cfg(feature = "op")]
+        let native_value_field_addable = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::NativeValue(_)))
+            .map(|f| !matches!(f.addable, Addable::Disable))
+            .collect::<Vec<_>>();
+
         let mapped_attributes = attributes
             .iter()
             .map(|a| {
@@ -130,7 +157,7 @@ impl Filler {
                         }
                     )*
                     #(
-                        if self.#native_value_field_names != #native_value_field_values {
+                        if self.#native_value_field_names != #native_value_field_empty_values {
                             return false
                         }
                     )*
@@ -141,11 +168,67 @@ impl Filler {
         #[cfg(not(feature = "status"))]
         let status_impl = quote!();
 
+        #[cfg(feature = "op")]
+        let op_impl = quote! {
+            impl #generics core::ops::Shl<#name #generics> for #struct_name #generics #where_clause {
+                type Output = Self;
+
+                fn shl(mut self, rhs: #name #generics) -> Self {
+                    struct_patch::traits::Filler::apply(&mut self, rhs);
+                    self
+                }
+            }
+
+            impl #generics core::ops::Add<Self> for #name #generics #where_clause {
+                type Output = Self;
+
+                fn add(mut self, rhs: Self) -> Self {
+                    #(
+                        if self.#native_value_field_names == #native_value_field_empty_values {
+                            self.#native_value_field_names = rhs.#native_value_field_names;
+                        } else if #native_value_field_addable {
+                            self.#native_value_field_names = self.#native_value_field_names + rhs.#native_value_field_names;
+                        } else {
+                            panic!("`{}` conflict in fillers, please use `#[filler(addable)]`", stringify!(#native_value_field_names))
+                        }
+                    )*
+                    #(
+                        if self.#extendable_field_names.is_empty() {
+                            self.#extendable_field_names = rhs.#extendable_field_names;
+                        } else if #extendable_field_addable {
+                            self.#extendable_field_names.extend(rhs.#extendable_field_names.into_iter());
+                        } else {
+                            panic!("`{}` conflict in fillers, please use `#[filler(addable)]`", stringify!(#extendable_field_names))
+                        }
+                    )*
+                    #(
+                        if let Some(b) = self.#option_field_names {
+                            if let Some(a) = rhs.#option_field_names {
+                                if #option_field_names_addable {
+                                    self.#option_field_names = Some(a + &b);
+                                } else {
+                                    panic!("`{}` conflict in fillers, please use `#[filler(addable)]`", stringify!(#option_field_names))
+                                }
+                            } else {
+                                self.#option_field_names = Some(b);
+                            }
+                        } else {
+                            self.#option_field_names = rhs.#option_field_names;
+                        }
+                    )*
+                    self
+                }
+            }
+        };
+
+        #[cfg(not(feature = "op"))]
+        let op_impl = quote!();
+
         let filler_impl = quote! {
             impl #generics struct_patch::traits::Filler< #name #generics > for #struct_name #generics #where_clause  {
                 fn apply(&mut self, filler: #name #generics) {
                     #(
-                        if self.#native_value_field_names == #native_value_field_values {
+                        if self.#native_value_field_names == #native_value_field_empty_values {
                             self.#native_value_field_names = filler.#native_value_field_names;
                         }
                     )*
@@ -167,7 +250,7 @@ impl Filler {
                     #name {
                         #(#option_field_names: None,)*
                         #(#extendable_field_names: #extendable_field_types::default(),)*
-                        #(#native_value_field_names: #native_value_field_values,)*
+                        #(#native_value_field_names: #native_value_field_empty_values,)*
                     }
                 }
             }
@@ -177,6 +260,7 @@ impl Filler {
             #filler_struct
             #status_impl
             #filler_impl
+            #op_impl
         })
     }
 
@@ -293,6 +377,8 @@ impl Field {
     ) -> Result<Option<Field>> {
         let mut fty = filler_type(&ty);
         let mut attributes = vec![];
+        #[cfg(feature = "op")]
+        let mut addable = Addable::Disable;
 
         for attr in attrs {
             if attr.path().to_string().as_str() != FILLER {
@@ -336,9 +422,21 @@ impl Field {
                                 .error("empty_value needs a clear value to define empty"));
                         }
                     }
+                    #[cfg(feature = "op")]
+                    ADDABLE => {
+                        // #[filler(addable)]
+                        addable = Addable::AddTrait;
+                    }
+                    #[cfg(not(feature = "op"))]
+                    ADDABLE => {
+                        return Err(syn::Error::new(
+                            ident.span(),
+                            "`addable` needs `op` feature",
+                        ));
+                    },
                     _ => {
                         return Err(meta.error(format_args!(
-                            "unknown filler field attribute `{}`",
+                            "unknown patch field attribute `{}`",
                             path.replace(' ', "")
                         )));
                     }
@@ -352,6 +450,8 @@ impl Field {
             ty,
             attributes,
             fty,
+            #[cfg(feature = "op")]
+            addable,
         }))
     }
 }

struct-patch-derive/src/lib.rs

@@ -2,9 +2,18 @@ extern crate proc_macro;
 mod filler;
 mod patch;
 
+use proc_macro2::Ident;
+
 use filler::Filler;
 use patch::Patch;
 
+#[cfg(feature = "op")]
+pub(crate) enum Addable {
+    Disable,
+    AddTrait,
+    AddFn(Ident),
+}
+
 #[proc_macro_derive(Patch, attributes(patch))]
 pub fn derive_patch(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     Patch::from_ast(syn::parse_macro_input!(item as syn::DeriveInput))

struct-patch-derive/src/patch.rs

@@ -7,6 +7,9 @@ use syn::{
     Type,
 };
 
+#[cfg(feature = "op")]
+use crate::Addable;
+
 const PATCH: &str = "patch";
 const NAME: &str = "name";
 const ATTRIBUTE: &str = "attribute";
@@ -23,14 +26,6 @@ pub(crate) struct Patch {
     fields: Vec<Field>,
 }
 
-#[cfg(feature = "op")]
-pub(crate) enum Addable {
-    Disable,
-    AddTriat,
-    #[cfg(feature = "op")]
-    AddFn(Ident),
-}
-
 struct Field {
     ident: Option<Ident>,
     ty: Type,
@@ -131,8 +126,8 @@ impl Patch {
             .iter()
             .map(|f| {
                 match &f.addable {
-                    Addable::AddTriat => quote!(
-                        Some(a + b)
+                    Addable::AddTrait => quote!(
+                        Some(a + &b)
                     ),
                     Addable::AddFn(f) => {
                         quote!(
@@ -472,7 +467,7 @@ impl Field {
                     #[cfg(feature = "op")]
                     ADDABLE => {
                         // #[patch(addable)]
-                        addable = Addable::AddTriat;
+                        addable = Addable::AddTrait;
                     }
                     #[cfg(not(feature = "op"))]
                     ADDABLE => {

struct-patch/examples/filler.rs

@@ -5,7 +5,7 @@ use struct_patch::Filler;
 use struct_patch::Status;
 
 // NOTE: Default, Extend, IntoIterator, is_empty are required for extendable type
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 struct WrapVec {
     inner: Vec<usize>,
 }
@@ -30,16 +30,20 @@ impl WrapVec {
     }
 }
 
-#[derive(Default, Filler)]
-#[filler(attribute(derive(Debug, Default)))]
+#[derive(Clone, Default, Filler)]
+#[filler(attribute(derive(Clone, Debug, Default)))]
 struct Item {
     field_complete: bool,
     // Will check the field is equal to the value to define the field is empty or not
     #[filler(empty_value = 0)]
+    // Will allow field add each other when `+` on fillers
+    #[filler(addable)]
     field_int: usize,
     field_string: String,
     maybe_field_int: Option<usize>,
     maybe_field_string: Option<String>,
+    // Will allow field extend each other when `+` on fillers
+    #[filler(addable)]
     list: Vec<usize>,
     _deque: VecDeque<usize>,
     _linked_list: LinkedList<usize>,
@@ -127,4 +131,36 @@ fn main() {
     filler.field_int = 5;
     item.apply(filler);
     assert_eq!(item.field_int, 7);
+
+    #[cfg(feature = "op")]
+    {
+        let item = Item::default();
+
+        let mut filler1: ItemFiller = Item::new_empty_filler();
+        filler1.field_int = 7;
+        filler1.list = vec![1, 2];
+
+        let mut filler2: ItemFiller = Item::new_empty_filler();
+        filler2.field_int = 8;
+        filler2.list = vec![3, 4];
+        filler2.maybe_field_string = Some("Something".into());
+
+        let final_item_from_added_fillers = item.clone() << (filler1.clone() + filler2.clone());
+
+        assert_eq!(final_item_from_added_fillers.field_int, 15);
+        assert_eq!(final_item_from_added_fillers.list, vec![1, 2, 3, 4]);
+        assert_eq!(
+            final_item_from_added_fillers.maybe_field_string,
+            Some("Something".into())
+        );
+
+        let final_item_after_fillers_applied = item << filler1 << filler2;
+
+        assert_eq!(final_item_after_fillers_applied.field_int, 7);
+        assert_eq!(final_item_after_fillers_applied.list, vec![1, 2]);
+        assert_eq!(
+            final_item_after_fillers_applied.maybe_field_string,
+            Some("Something".into())
+        );
+    }
 }