add feature to generate setters in the Difference proc macro

knickish · knickish · commit 6f1943b29020 · 2023-05-10T19:40:33.000-05:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "structdiff"
-version = "0.5.6"
+version = "0.5.7"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/knickish/structdiff"
@@ -11,13 +11,14 @@ categories    = ["compression"]
 [dependencies]
 nanoserde           = { version = "^0.1.32", optional = true }
 serde               = { version = "^1.0.0", optional = true, features = ["derive"] }
-structdiff-derive   = { path = "derive", version = "=0.5.6" }
+structdiff-derive   = { path = "derive", version = "=0.5.7" }
 
 [features]
 "default"       = []
 "nanoserde"     = ["dep:nanoserde", "structdiff-derive/nanoserde"]
 "serde"         = ["dep:serde", "structdiff-derive/serde"]
 "debug_diffs"   = ["structdiff-derive/debug_diffs"]
+"generated_setters" = ["structdiff-derive/generated_setters"]
 
 [dev-dependencies]
 bincode             = "1.3.3"
diff --git a/README.md b/README.md
@@ -48,18 +48,23 @@ assert_ne!(diffed, second);
 For more examples take a look at [integration tests](/tests)
 
 ## Derive macro attributes
-- `#[difference(skip)]`     - Do not consider this field when creating a diff
-- `#[difference(recurse)]`  - Generate a StructDiff for this field when creating a diff
+- `#[difference(skip)]` - Do not consider this field when creating a diff
+- `#[difference(recurse)]` - Generate a StructDiff for this field when creating a diff
 - `#[difference(collection_strategy = {})]` 
     - `"unordered_array_like"` - Generates a changeset for array-like collections of items which implement `Hash + Eq`, rather than cloning the entire list. (currently works for `Vec`, `BTreeSet`, `LinkedList`, and `HashSet`)
     - `"unordered_map_like"` - Generates a changeset for map-like collections for which the key implements `Hash + Eq`, rather than cloning the entire map. (currently works for `HashMap` and `BTreeMap`)
 - `#[difference(map_equality = {})]` - Used with `unordered_map_like`, specifies whether the equality check should consider keys only, or both keys and values
     - `"key_only"` - only replace a key-value pair for which the key has changed
     - `"key_and_value"` - replace a key-value pair if either the key or value has changed
+- `#[difference(setters)]` - Generate setters for all fields in the struct (used on struct)
+    - Example: for the `field1` of the `Example` struct used above, a function with the signature `set_field1_with_diff(&mut self, value: Option<usize>) -> Option<<Self as StructDiff>::Diff>` will be generated. Useful when a single field will be changed in a struct with many fields, as it saves the comparison of all other fields. 
+- `#[difference(setter)]` - Generate setters for this struct field (used on field)
+- `#[difference(setter_name = {})]` - Use this name instead of the default value when generating a setter for this field (used on field)
 
 ## Optional features
 - [`nanoserde`, `serde`] - Serialization of `Difference` derived associated types. Allows diffs to easily be sent over network.
 - `debug_diffs` - Derive `Debug` on the generated diff type
+- `generated_setters` - Enable generation of setters for struct fields. These setters automatically return a diff if a field's value is changed by the assignment.
 
 ### Development status 
 This is being used actively for my own projects, although it's mostly working now. PRs will be accepted for either more tests or functionality.
diff --git a/derive/Cargo.toml b/derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "structdiff-derive"
-version = "0.5.6"
+version = "0.5.7"
 authors = ["Makepad <info@makepad.nl>", "Fedor <not.fl3@gmail.com>", "Kirk <knickish@gmail.com"]
 edition = "2018"
 description = "Fork of nanoserde's parsing library"
@@ -18,3 +18,4 @@ serde               = { version = "^1.0.0", optional = true, features = ["derive
 "nanoserde" = ["dep:nanoserde"]
 "serde"     = ["dep:serde"]
 "debug_diffs" = []
+"generated_setters" = []
diff --git a/derive/src/difference.rs b/derive/src/difference.rs
diff --git a/derive/src/shared.rs b/derive/src/shared.rs
@@ -21,6 +21,36 @@ pub enum CollectionStrategy {
     UnorderedMapLikeHash(MapStrategy),
 }
 
+#[cfg(feature = "generated_setters")]
+pub fn attrs_setter(attributes: &[crate::parse::Attribute]) -> (bool, bool, Option<String>) {
+    let skip = attributes
+    .iter()
+    .any(|attr| attr.tokens.len() == 1 && attr.tokens[0] == "skip_setter");
+    let local = attributes
+    .iter()
+    .any(|attr| attr.tokens.len() == 1 && attr.tokens[0] == "setter");
+
+    let Some(name_override) = attributes.iter().find_map(|attr| {
+        if attr.tokens.len() == 2 && attr.tokens[0] == "setter_name" {
+            
+            Some(attr.tokens[1].clone())
+        } else {
+            None
+        }
+    }) else {
+        return (local, skip, None);
+    };
+
+    (local, skip, Some(name_override))
+}
+
+#[cfg(feature = "generated_setters")]
+pub fn attrs_all_setters(attributes: &[crate::parse::Attribute]) -> bool {
+    attributes
+    .iter()
+    .any(|attr| attr.tokens.len() == 1 && attr.tokens[0] == "setters")
+}
+
 pub fn attrs_recurse(attributes: &[crate::parse::Attribute]) -> bool {
     attributes
         .iter()
diff --git a/src/collections/unordered_array_like.rs b/src/collections/unordered_array_like.rs
@@ -429,6 +429,7 @@ mod test {
     #[test]
     fn test_collection_strategies() {
         #[derive(Debug, PartialEq, Clone, Difference, Default)]
+        #[difference(setters)]
         struct TestCollection {
             #[difference(collection_strategy = "unordered_array_like")]
             test1: Vec<i32>,
diff --git a/src/collections/unordered_map_like.rs b/src/collections/unordered_map_like.rs
@@ -508,6 +508,7 @@ mod test {
     #[test]
     fn test_key_only() {
         #[derive(Debug, PartialEq, Clone, Difference, Default)]
+        #[difference(setters)]
         struct TestCollection {
             #[difference(collection_strategy = "unordered_map_like")]
             test1: HashMap<i32, i32>,
@@ -572,6 +573,7 @@ mod test {
     #[test]
     fn test_key_value() {
         #[derive(Debug, PartialEq, Clone, Difference, Default)]
+        #[difference(setters)]
         struct TestCollection {
             #[difference(
                 collection_strategy = "unordered_map_like",
diff --git a/src/collections/unordered_map_like_recursive.rs b/src/collections/unordered_map_like_recursive.rs
@@ -436,12 +436,14 @@ mod test {
         #[cfg_attr(feature = "nanoserde", derive(DeBin, SerBin))]
         #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
         #[derive(Debug, PartialEq, Clone, Difference, Default)]
+        #[difference(setters)]
         pub struct TestRecurse {
             recurse1: i32,
             recurse2: Option<String>,
         }
 
         #[derive(Debug, PartialEq, Clone, Difference, Default)]
+        #[difference(setters)]
         struct TestCollection {
             #[difference(
                 collection_strategy = "unordered_map_like",
diff --git a/tests/derives.rs b/tests/derives.rs
@@ -12,6 +12,7 @@ use structdiff::{Difference, StructDiff};
 #[allow(dead_code)]
 #[cfg(not(any(feature = "serde", feature = "nanoserde")))]
 #[derive(Difference)]
+// #[difference(setters)]
 pub struct TestDeriveAll<
     'a,
     'b: 'a,
diff --git a/tests/enums.rs b/tests/enums.rs
@@ -11,6 +11,7 @@ use structdiff::{Difference, StructDiff};
 #[cfg(not(feature = "nanoserde"))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, PartialEq, Clone, Difference, Default)]
+#[difference(setters)]
 pub struct Test {
     pub test1: i32,
     pub test2: String,
@@ -21,6 +22,7 @@ pub struct Test {
 
 #[cfg(not(feature = "nanoserde"))]
 #[derive(Debug, PartialEq, Clone, Difference)]
+#[difference(setters)]
 pub struct TestSkip<A>
 where
     A: PartialEq,
diff --git a/tests/integration.rs b/tests/integration.rs
@@ -3,6 +3,7 @@
 mod derives;
 mod enums;
 mod types;
+use assert_unordered::{assert_eq_unordered, assert_eq_unordered_sort};
 #[cfg(not(feature = "nanoserde"))]
 pub use types::{RandValue, Test, TestEnum, TestSkip};
 
@@ -137,6 +138,7 @@ fn test_derive_with_skip() {
 #[cfg(not(feature = "nanoserde"))] // this is broken until nanoserde fixes its generic serde
 #[derive(Debug, PartialEq, Clone, Difference)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[difference(setters)]
 struct TestGenerics<A, B, C, RS: Eq + Hash> {
     test1: A,
     test2: B,
@@ -191,6 +193,7 @@ fn test_generics() {
 
 #[cfg(not(feature = "nanoserde"))]
 #[derive(Debug, PartialEq, Clone, Difference)]
+#[difference(setters)]
 struct TestGenericsSkip<A, B, C, RS: Eq + Hash> {
     test1: A,
     test2: B,
@@ -303,6 +306,7 @@ mod derive_inner {
 #[test]
 fn test_recurse() {
     #[derive(Debug, PartialEq, Clone, Difference)]
+    #[difference(setters)]
     struct TestRecurse {
         test1: i32,
         #[difference(recurse)]
@@ -496,3 +500,43 @@ fn test_key_value() {
     use assert_unordered::assert_eq_unordered;
     assert_eq_unordered!(diffed.test1, second.test1);
 }
+
+#[cfg(feature = "generated_setters")]
+#[test]
+fn test_setters() {
+    use types::TestSetters;
+    let mut base = TestSetters::default();
+    let mut end = TestSetters::default();
+    let mut partial_diffs = vec![];
+    let mut full_diffs = vec![];
+
+    for _ in 0..100 {
+        end = TestSetters::next();
+        partial_diffs.extend(base.testing123(end.f0.clone()));
+        partial_diffs.extend(base.set_f1_with_diff(end.f1.clone()));
+        partial_diffs.extend(base.set_f2_with_diff(end.f2.clone()));
+        partial_diffs.extend(base.set_f3_with_diff(end.f3.clone()));
+        partial_diffs.extend(base.set_f4_with_diff(end.f4.clone()));
+        partial_diffs.extend(base.set_f5_with_diff(end.f5.clone()));
+        partial_diffs.extend(base.set_f6_with_diff(end.f6.clone()));
+        let tmp = base.apply_ref(partial_diffs.clone());
+        assert_eq!(&tmp.f0, &end.f0);
+        assert_eq!(&tmp.f1, &end.f1);
+        assert_eq!(&tmp.f2, &end.f2);
+        assert_eq!(&tmp.f3, &end.f3);
+        assert_eq_unordered!(&tmp.f4, &end.f4);
+        assert_eq_unordered!(&tmp.f5, &end.f5);
+        assert_eq_unordered!(&tmp.f6, &end.f6);
+        base = end.clone();
+        full_diffs.extend(std::mem::take(&mut partial_diffs));
+    }
+
+    let modified = TestSetters::default().apply(full_diffs);
+    assert_eq!(modified.f0, end.f0);
+    assert_eq!(modified.f1, end.f1);
+    assert_eq!(modified.f2, end.f2);
+    assert_eq!(modified.f3, end.f3);
+    assert_eq_unordered_sort!(modified.f4, end.f4);
+    assert_eq_unordered!(modified.f5, end.f5);
+    assert_eq_unordered!(modified.f6, end.f6);
+}
diff --git a/tests/types.rs b/tests/types.rs
@@ -1,16 +1,27 @@
+use std::collections::BTreeMap;
+
 use generators::{fill, rand_string};
 use nanorand::{Rng, WyRand};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use structdiff::{Difference, StructDiff};
 
-pub trait RandValue {
-    fn next() -> Self;
+pub trait RandValue
+where
+    Self: Sized,
+{
+    fn next() -> Self {
+        let mut rng = WyRand::new();
+        Self::next_seeded(&mut rng)
+    }
+
+    fn next_seeded(rng: &mut WyRand) -> Self;
 }
 
 #[cfg(not(feature = "nanoserde"))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, PartialEq, Clone, Difference, Default)]
+#[difference(setters)]
 pub struct Test {
     pub test1: i32,
     pub test2: String,
@@ -21,6 +32,7 @@ pub struct Test {
 
 #[cfg(not(feature = "nanoserde"))]
 #[derive(Debug, PartialEq, Clone, Difference)]
+#[difference(setters)]
 pub struct TestSkip<A>
 where
     A: PartialEq,
@@ -49,13 +61,15 @@ pub enum TestEnum {
 
 #[cfg(not(feature = "nanoserde"))]
 impl RandValue for Test {
-    fn next() -> Self {
-        let mut rng = WyRand::new();
+    fn next_seeded(rng: &mut WyRand) -> Self {
         Test {
             test1: rng.generate(),
-            test2: rand_string(&mut rng),
-            test3: fill(&mut rng),
-            test4: f32::from_bits(rng.generate::<u32>()),
+            test2: rand_string(rng),
+            test3: fill(rng),
+            test4: match f32::from_bits(rng.generate::<u32>()) {
+                val if val.is_nan() => 0.0,
+                val => val,
+            },
             test5: match rng.generate::<bool>() {
                 true => Some(rng.generate()),
                 false => None,
@@ -66,21 +80,66 @@ impl RandValue for Test {
 
 #[cfg(not(feature = "nanoserde"))]
 impl RandValue for TestEnum {
-    fn next() -> Self {
-        let mut rng = WyRand::new();
+    fn next_seeded(rng: &mut WyRand) -> Self {
         match rng.generate_range(0..5) {
             0 => Self::F0,
             1 => Self::F1(()),
-            2 => Self::F2(rand_string(&mut rng)),
+            2 => Self::F2(rand_string(rng)),
             3 => Self::F3 {
-                field1: rand_string(&mut rng),
+                field1: rand_string(rng),
                 field2: (),
             },
             _ => Self::F4(Test::next()),
         }
     }
 }
 
+#[derive(Difference, Default, PartialEq, Debug, Clone)]
+#[difference(setters)]
+pub struct TestSetters {
+    #[difference(setter_name = "testing123", recurse)]
+    pub f0: Test,
+    pub f1: Test,
+    pub f2: TestEnum,
+    #[difference(recurse)]
+    pub f3: Option<Test>,
+    #[difference(collection_strategy = "unordered_array_like")]
+    pub f4: Vec<i32>,
+    #[difference(collection_strategy = "unordered_map_like", map_equality = "key_only")]
+    pub f5: BTreeMap<i32, Test>,
+    #[difference(
+        collection_strategy = "unordered_map_like",
+        map_equality = "key_and_value"
+    )]
+    pub f6: BTreeMap<i32, Test>,
+}
+
+impl RandValue for TestSetters {
+    fn next_seeded(rng: &mut WyRand) -> Self {
+        TestSetters {
+            f0: Test::next(),
+            f1: Test::next(),
+            f2: TestEnum::next(),
+            f3: if rng.generate::<bool>() {
+                Some(Test::next_seeded(rng))
+            } else {
+                None
+            },
+            f4: generators::fill(rng),
+            f5: generators::fill::<i32, Vec<i32>>(rng)
+                .into_iter()
+                .map(|x| (x, Test::next_seeded(rng)))
+                .take(10)
+                .collect(),
+            f6: generators::fill::<i32, Vec<i32>>(rng)
+                .into_iter()
+                .map(|x| (x, Test::next_seeded(rng)))
+                .take(10)
+                .collect(),
+        }
+    }
+}
+
 mod generators {
     use nanorand::{Rng, WyRand};
 
