Add nesting feature (#98)

* Add nesting feature
* update readme and bounce version

Author: yanganto

.github/workflows/lint.yml

@@ -29,3 +29,4 @@ jobs:
           nix develop -c cargo clippy --features=option -- -Dwarnings
           nix develop -c cargo clippy --features=none_as_default -- -Dwarnings
           nix develop -c cargo clippy --features=keep_none -- -Dwarnings
+          nix develop -c cargo clippy --features=nesting -- -Dwarnings

.github/workflows/test.yml

@@ -26,6 +26,7 @@ jobs:
           nix develop -c cargo run --no-default-features --example rename-patch-struct
           nix develop -c cargo run --no-default-features --example patch-attr
           nix develop -c cargo run --no-default-features --example time
+          nix develop -c cargo run --no-default-features --features=nesting --example nesting
           nix develop -c cargo test --no-default-features
 
       - name: Test with std features

Cargo.toml

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

README.md

@@ -126,6 +126,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 a patch nesting other patch
 - show filler with all possible types
 
 ## Features
@@ -141,6 +142,7 @@ This crate also includes the following optional features:
     - default: `T` needs to implement `From<P>`.  When patching on None, it will based on `from<P>` to cast T, and this let you patch structs containing fields with optional values.
     - `none_as_default`: `T` needs to implement `Default`.  When patching on None, it will patch on a default instance, and this also let you patch structs containing fields with optional values.
     - `keep_none`: When patching on None, it is still None.
+- `nesting`(optional): allow a inner field with `Patch` derive and `#[patch(nesting)]` attribute
 
 [crates-badge]: https://img.shields.io/crates/v/struct-patch.svg
 [crate-url]: https://crates.io/crates/struct-patch

struct-patch-derive/Cargo.toml

@@ -22,6 +22,7 @@ syn = { version =  "2.0", features = ["parsing"] }
 status = []
 op = []
 merge = []
+nesting = []
 
 [dev-dependencies]
 pretty_assertions_sorted = "1.2.3"

struct-patch-derive/src/patch.rs

@@ -13,6 +13,7 @@ const ATTRIBUTE: &str = "attribute";
 const SKIP: &str = "skip";
 const ADDABLE: &str = "addable";
 const ADD: &str = "add";
+const NESTING: &str = "nesting";
 
 pub(crate) struct Patch {
     visibility: syn::Visibility,
@@ -38,6 +39,8 @@ struct Field {
     retyped: bool,
     #[cfg(feature = "op")]
     addable: Addable,
+    #[cfg(feature = "nesting")]
+    nesting: bool,
 }
 
 impl Patch {
@@ -56,20 +59,60 @@ impl Patch {
             .iter()
             .map(|f| f.to_token_stream())
             .collect::<Result<Vec<_>>>()?;
+
+        #[cfg(not(feature = "nesting"))]
         let field_names = fields.iter().map(|f| f.ident.as_ref()).collect::<Vec<_>>();
+        #[cfg(feature = "nesting")]
+        let field_names = fields
+            .iter()
+            .filter(|f| !f.nesting)
+            .map(|f| f.ident.as_ref()).collect::<Vec<_>>();
 
+        #[cfg(not(feature = "nesting"))]
         let renamed_field_names = fields
             .iter()
             .filter(|f| f.retyped)
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
+        #[cfg(feature = "nesting")]
+        let renamed_field_names = fields
+            .iter()
+            .filter(|f| f.retyped && !f.nesting)
+            .map(|f| f.ident.as_ref())
+            .collect::<Vec<_>>();
 
+        #[cfg(not(feature = "nesting"))]
         let original_field_names = fields
             .iter()
             .filter(|f| !f.retyped)
             .map(|f| f.ident.as_ref())
             .collect::<Vec<_>>();
 
+        #[cfg(feature = "nesting")]
+        let original_field_names = fields
+            .iter()
+            .filter(|f| !f.retyped && !f.nesting)
+            .map(|f| f.ident.as_ref())
+            .collect::<Vec<_>>();
+
+        #[cfg(not(feature = "nesting"))]
+        let nesting_field_names: Vec<String> = Vec::new();
+        #[cfg(not(feature = "nesting"))]
+        let nesting_field_types: Vec<Type> = Vec::new();
+
+        #[cfg(feature = "nesting")]
+        let nesting_field_names = fields
+            .iter()
+            .filter(|f| f.nesting)
+            .map(|f| f.ident.as_ref())
+            .collect::<Vec<_>>();
+        #[cfg(feature = "nesting")]
+        let nesting_field_types = fields
+            .iter()
+            .filter(|f| f.nesting)
+            .map(|f| f.ty.clone())
+            .collect::<Vec<_>>();
+
         let mapped_attributes = attributes
             .iter()
             .map(|a| {
@@ -119,6 +162,9 @@ impl Patch {
                         #(
                             #original_field_names: other.#original_field_names.or(self.#original_field_names),
                         )*
+                        #(
+                            #nesting_field_names: other.#nesting_field_names.apply(self.#nesting_field_names),
+                        )*
                     }
                 }
             }
@@ -252,6 +298,9 @@ impl Patch {
                             self.#original_field_names = v;
                         }
                     )*
+                    #(
+                        self.#nesting_field_names.apply(patch.#nesting_field_names);
+                    )*
                 }
 
                 fn into_patch(self) -> #name #generics {
@@ -262,6 +311,9 @@ impl Patch {
                         #(
                             #original_field_names: Some(self.#original_field_names),
                         )*
+                        #(
+                            #nesting_field_names: self.#nesting_field_names.into_patch(),
+                        )*
                     }
                 }
 
@@ -283,6 +335,9 @@ impl Patch {
                                 None
                             },
                         )*
+                        #(
+                            #nesting_field_names: self.#nesting_field_names.into_patch_by_diff(previous_struct.#nesting_field_names),
+                        )*
                     }
                 }
 
@@ -291,6 +346,9 @@ impl Patch {
                         #(
                             #field_names: None,
                         )*
+                        #(
+                            #nesting_field_names: #nesting_field_types::new_empty_patch(),
+                        )*
                     }
                 }
             }
@@ -403,6 +461,8 @@ impl Field {
             ident,
             ty,
             attributes,
+            #[cfg(feature = "nesting")]
+            nesting,
             ..
         } = self;
 
@@ -415,14 +475,48 @@ impl Field {
             })
             .collect::<Vec<_>>();
         match ident {
+            #[cfg(not(feature = "nesting"))]
             Some(ident) => Ok(quote! {
                 #(#attributes)*
                 pub #ident: Option<#ty>,
             }),
+            #[cfg(feature = "nesting")]
+            Some(ident) => {
+                if *nesting {
+                    // TODO handle rename
+                    let patch_type = syn::Ident::new(&format!("{}Patch", &ty.to_token_stream()), Span::call_site());
+                    Ok(quote! {
+                        #(#attributes)*
+                        pub #ident: #patch_type,
+                    })
+                } else {
+                    Ok(quote! {
+                        #(#attributes)*
+                        pub #ident: Option<#ty>,
+                    })
+                }
+            },
+            #[cfg(not(feature = "nesting"))]
             None => Ok(quote! {
                 #(#attributes)*
                 pub Option<#ty>,
             }),
+            #[cfg(feature = "nesting")]
+            None => {
+                if *nesting {
+                    // TODO handle rename
+                    let patch_type = syn::Ident::new(&format!("{}Patch", &ty.to_token_stream()), Span::call_site());
+                    Ok(quote! {
+                        #(#attributes)*
+                        pub #patch_type,
+                    })
+                } else {
+                    Ok(quote! {
+                        #(#attributes)*
+                        pub Option<#ty>,
+                    })
+                }
+            },
         }
     }
 
@@ -438,6 +532,8 @@ impl Field {
 
         #[cfg(feature = "op")]
         let mut addable = Addable::Disable;
+        #[cfg(feature = "nesting")]
+        let mut nesting = false;
 
         for attr in attrs {
             if attr.path().to_string().as_str() != PATCH {
@@ -491,6 +587,16 @@ impl Field {
                     ADD => {
                         return Err(syn::Error::new(ident.span(), "`add` needs `op` feature"));
                     }
+                    #[cfg(feature = "nesting")]
+                    NESTING => {
+                        // #[patch(nesting)]
+                        nesting = true;
+                    }
+                    #[cfg(not(feature = "nesting"))]
+                    NESTING => {
+                        return Err(
+                            meta.error("#[patch(nesting)] only work with `nesting` feature"));
+                    }
                     _ => {
                         return Err(meta.error(format_args!(
                             "unknown patch field attribute `{}`",
@@ -512,6 +618,8 @@ impl Field {
             attributes,
             #[cfg(feature = "op")]
             addable,
+            #[cfg(feature = "nesting")]
+            nesting,
         }))
     }
 }

struct-patch/Cargo.toml

@@ -11,7 +11,7 @@ license.workspace = true
 readme.workspace = true
 
 [dependencies]
-struct-patch-derive = { version = "=0.9.4", path = "../struct-patch-derive" }
+struct-patch-derive = { version = "=0.10.0", path = "../struct-patch-derive" }
 
 [dev-dependencies]
 serde_json = "1.0"
@@ -35,5 +35,6 @@ merge = [
 std = ["box", "option"]
 box = []
 option = []
+nesting = []
 none_as_default = ["option"]
 keep_none = ["option"]

struct-patch/examples/nesting.rs

@@ -0,0 +1,54 @@
+use serde::Deserialize;
+use struct_patch::Patch;
+
+#[cfg(feature = "nesting")]
+#[derive(Clone, Debug, Default, Patch, PartialEq)]
+#[patch(attribute(derive(Debug, Deserialize, PartialEq)))]
+struct Item {
+    field_complete: bool,
+    field_int: usize,
+    field_string: String,
+    #[patch(nesting)]
+    inner: Nesting,
+}
+
+#[derive(Clone, Debug, Default, Patch, PartialEq)]
+#[patch(attribute(derive(Debug, Deserialize, PartialEq)))]
+struct Nesting {
+    inner_int: usize,
+    inner_string: String,
+}
+
+#[cfg(not(feature = "nesting"))]
+fn main() {}
+
+#[cfg(feature = "nesting")]
+fn main() {
+    let item_a = Item::default();
+    let item_b = Item {
+        field_int: 7,
+        inner: Nesting {
+            inner_int: 100,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+
+    let patch = item_b.clone().into_patch_by_diff(item_a);
+    assert_eq!(
+        format!("{patch:?}"),
+        "ItemPatch { field_complete: None, field_int: Some(7), field_string: None, inner: NestingPatch { inner_int: Some(100), inner_string: None } }"
+    );
+
+    let data = r#"{
+        "field_int": 7,
+        "inner": {
+            "inner_int": 100
+        }
+    }"#;
+    assert_eq!(patch, serde_json::from_str(data).unwrap());
+
+    let mut item = Item::default();
+    item.apply(patch);
+    assert_eq!(item, item_b);
+}