Handle extenable types (#90)

* handle extendable types in collections
* implement `#[filler(extendable)]`
* bounce version
* readme

Author: yanganto

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 
 [workspace.package]
 authors = ["Antonio Yang <yanganto@gmail.com>"]
-version = "0.9.1"
+version = "0.9.2"
 edition = "2021"
 categories = ["development-tools"]
 keywords = ["struct", "patch", "macro", "derive", "overlay"]

README.md

@@ -100,7 +100,7 @@ assert_eq!(item.list, vec![7]);
 ``` 
 
 ## Documentation and Examples
-Also, you can modify the patch structure by defining `#[patch(...)]` attributes on the original struct or fields.
+Also, you can modify the patch structure by defining `#[patch(...)]` or `#[filler(...)]` attributes on the original struct or fields.
 
 Struct attributes:
 - `#[patch(name = "...")]`: change the name of the generated patch struct.
@@ -112,6 +112,7 @@ Field attributes:
 - `#[patch(name = "...")]`: change the type of the field in the generated patch struct.
 - `#[patch(attribute(...))]`: add attributes to the field in the generated patch struct.
 - `#[patch(attribute(derive(...)))]`: add derives to the field in the generated patch struct.
+- `#[filler(extendable)]`: use the struct of field for Filler, the struct needs implement `Default`, `Extend`, `IntoIterator` and `is_empty`.
 
 Please check the [traits][doc-traits] of document to learn more.
 
@@ -124,6 +125,7 @@ The [examples][examples] demo following scenarios.
 - show option field behavior
 - show operators about patches
 - show example with serde crates, ex: `humantime_serde` for duration
+- show filler with all possible types
 
 ## Features
 This crate also includes the following optional features:

struct-patch-derive/src/filler.rs

@@ -5,6 +5,7 @@ use syn::{parenthesized, DeriveInput, LitStr, Result, Type};
 
 const FILLER: &str = "filler";
 const ATTRIBUTE: &str = "attribute";
+const EXTENDABLE: &str = "extendable";
 
 pub(crate) struct Filler {
     visibility: syn::Visibility,
@@ -18,7 +19,17 @@ pub(crate) struct Filler {
 #[derive(Debug, PartialEq)]
 enum FillerType {
     Option,
-    Vec,
+    Extendable(Ident),
+}
+
+impl FillerType {
+    fn inner(&self) -> &Ident {
+        if let FillerType::Extendable(ident) = self {
+            ident
+        } else {
+            panic!("FillerType::Option has no inner indent")
+        }
+    }
 }
 
 struct Field {
@@ -45,18 +56,24 @@ impl Filler {
             .map(|f| f.to_token_stream())
             .collect::<Result<Vec<_>>>()?;
 
-        let vector_field_names = fields
+        let option_field_names = fields
             .iter()
-            .filter(|f| f.fty == FillerType::Vec)
+            .filter(|f| f.fty == FillerType::Option)
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
 
-        let option_field_names = fields
+        let extendable_field_names = fields
             .iter()
-            .filter(|f| f.fty == FillerType::Option)
+            .filter(|f| matches!(f.fty, FillerType::Extendable(_)))
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
 
+        let extendable_field_types = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::Extendable(_)))
+            .map(|f| f.fty.inner())
+            .collect::<Vec<_>>();
+
         let mapped_attributes = attributes
             .iter()
             .map(|a| {
@@ -84,7 +101,7 @@ impl Filler {
                         }
                     )*
                     #(
-                        if !self.#vector_field_names.is_empty() {
+                        if !self.#extendable_field_names.is_empty() {
                             return false
                         }
                     )*
@@ -99,7 +116,9 @@ impl Filler {
             impl #generics struct_patch::traits::Filler< #name #generics > for #struct_name #generics #where_clause  {
                 fn apply(&mut self, filler: #name #generics) {
                     #(
-                        self.#vector_field_names.extend(filler.#vector_field_names.iter());
+                        if self.#extendable_field_names.is_empty() {
+                            self.#extendable_field_names.extend(filler.#extendable_field_names.into_iter());
+                        }
                     )*
                     #(
                         if let Some(v) = filler.#option_field_names {
@@ -113,7 +132,7 @@ impl Filler {
                 fn new_empty_filler() -> #name #generics {
                     #name {
                         #(#option_field_names: None,)*
-                        #(#vector_field_names: Vec::new(),)*
+                        #(#extendable_field_names: #extendable_field_types::default(),)*
                     }
                 }
             }
@@ -237,12 +256,7 @@ impl Field {
             ident, ty, attrs, ..
         }: syn::Field,
     ) -> Result<Option<Field>> {
-        let fty = if let Some(fty) = filler_type(&ty) {
-            fty
-        } else {
-            return Ok(None);
-        };
-
+        let mut fty = filler_type(&ty);
         let mut attributes = vec![];
 
         for attr in attrs {
@@ -266,6 +280,10 @@ impl Field {
                         let attribute: TokenStream = content.parse()?;
                         attributes.push(attribute);
                     }
+                    EXTENDABLE => {
+                        // #[filler(extendable)]
+                        fty = Some(FillerType::Extendable(extendable_filler_type(&ty)));
+                    }
                     _ => {
                         return Err(meta.error(format_args!(
                             "unknown filler field attribute `{}`",
@@ -277,7 +295,7 @@ impl Field {
             })?;
         }
 
-        Ok(Some(Field {
+        Ok(fty.map(|fty| Field {
             ident,
             ty,
             attributes,
@@ -305,13 +323,29 @@ fn filler_type(ty: &Type) -> Option<FillerType> {
                     return Some(FillerType::Option);
                 }
             }
-        } else if segments.len() == 1 && segments[0].ident == "Vec" {
+        } else if segments.len() == 1 && segments[0].ident == "Vec"
+            || segments[0].ident == "VecDeque"
+            || segments[0].ident == "LinkedList"
+            || segments[0].ident == "HashMap"
+            || segments[0].ident == "BTreeMap"
+            || segments[0].ident == "HashSet"
+            || segments[0].ident == "BTreeSet"
+            || segments[0].ident == "BinaryHeap"
+        {
             if let syn::PathArguments::AngleBracketed(args) = &segments[0].arguments {
                 if args.args.len() == 1 {
-                    return Some(FillerType::Vec);
+                    return Some(FillerType::Extendable(segments[0].ident.clone()));
                 }
             }
         }
     }
     None
 }
+
+fn extendable_filler_type(ty: &Type) -> Ident {
+    if let Type::Path(type_path) = ty {
+        type_path.path.segments[0].ident.clone()
+    } else {
+        panic!("#[filler(extendable)] should use on a type")
+    }
+}

struct-patch/Cargo.toml

@@ -11,7 +11,7 @@ license.workspace = true
 readme.workspace = true
 
 [dependencies]
-struct-patch-derive = { version = "=0.9.1", path = "../struct-patch-derive" }
+struct-patch-derive = { version = "=0.9.2", path = "../struct-patch-derive" }
 
 [dev-dependencies]
 serde_json = "1.0"

struct-patch/examples/filler.rs

@@ -1,7 +1,35 @@
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
+use std::iter::{Extend, IntoIterator, Iterator};
 use struct_patch::Filler;
 #[cfg(feature = "status")]
 use struct_patch::Status;
 
+// NOTE: Default, Extend, IntoIterator, is_empty are required for extendable type
+#[derive(Debug, Default)]
+struct WrapVec {
+    inner: Vec<usize>,
+}
+
+impl Extend<usize> for WrapVec {
+    fn extend<WrapVec: IntoIterator<Item = usize>>(&mut self, iter: WrapVec) {
+        self.inner.extend(iter.into_iter());
+    }
+}
+
+impl IntoIterator for WrapVec {
+    type Item = usize;
+    type IntoIter = Box<dyn Iterator<Item = Self::Item>>;
+    fn into_iter(self) -> Self::IntoIter {
+        Box::new(self.inner.into_iter())
+    }
+}
+
+impl WrapVec {
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
 #[derive(Default, Filler)]
 #[filler(attribute(derive(Debug, Default)))]
 struct Item {
@@ -11,6 +39,15 @@ struct Item {
     maybe_field_int: Option<usize>,
     maybe_field_string: Option<String>,
     list: Vec<usize>,
+    _deque: VecDeque<usize>,
+    _linked_list: LinkedList<usize>,
+    _map: HashMap<usize, usize>,
+    _bmap: BTreeMap<usize, usize>,
+    _set: HashSet<usize>,
+    _bset: BTreeSet<usize>,
+    _heap: BinaryHeap<usize>,
+    #[filler(extendable)]
+    _wrap: WrapVec,
 }
 
 // Generated by Filler derive macro
@@ -19,6 +56,14 @@ struct Item {
 // struct ItemFiller {
 //     maybe_field_int: Option<usize>,
 //     maybe_field_string: Option<String>,
+//     list: Vec<usize>,
+//     _deque: VecDeque<usize>,
+//     _linked_list: LinkedList<usize>,
+//     _map: HashMap<usize, usize>,
+//     _bmap: BTreeMap<usize, usize>,
+//     _set: HashSet<usize>,
+//     _bset: BTreeSet<usize>,
+//     _heap: BinaryHeap<usize>,
 // }
 
 fn main() {
@@ -36,7 +81,7 @@ fn main() {
 
     assert_eq!(
         format!("{filler:?}"),
-        "ItemFiller { maybe_field_int: Some(7), maybe_field_string: None, list: [] }"
+        "ItemFiller { maybe_field_int: Some(7), maybe_field_string: None, list: [], _deque: [], _linked_list: [], _set: {}, _bset: {}, _heap: [], _wrap: WrapVec { inner: [] } }"
     );
 
     item.apply(filler);
@@ -69,5 +114,5 @@ fn main() {
     let mut filler: ItemFiller = Item::new_empty_filler();
     filler.list = vec![3, 4];
     item.apply(filler);
-    assert_eq!(item.list, vec![1, 2, 3, 4]);
+    assert_eq!(item.list, vec![1, 2]);
 }

struct-patch/src/lib.rs

@@ -42,9 +42,14 @@
 //! }
 //! ```
 //!
-//! More details on how to use the the derive macro, including what attributes are available, are available under [`Patch`]
+//! More details on how to use the the derive macro, including what attributes are available, are
+//! available under [`Patch`]
 //!
-//! Deriving [`Filler`] on a struct will generate a struct similar to the original one with the field with `Option`.
+//! Deriving [`Filler`] on a struct will generate a struct similar to the original one with the
+//! field with `Option`, `BTreeMap`, `BTreeSet`, `BinaryHeap`,`HashMap`, `HashSet`, `LinkedList`,
+//! `VecDeque `or `Vec`.
+//! Any struct implement `Default`, `Extend`, `IntoIterator`, `is_empty` can be used with
+//! `#[filler(extenable)]`.
 //! Unlike [`Patch`], the [`Filler`] only work on the empty fields of instance.
 //!
 //! ```rust