Add support for sets

Author: Diggsey

README.md

@@ -52,6 +52,8 @@ serde_json
 - [x] BTreeMap (thanks @milkey-mouse)
 - [x] Fixed-size arrays (thanks @Boscop)
 - [x] Tuples (thanks @Boscop)
+- [x] HashSet (thanks @Diggsey)
+- [x] BTreeSet (thanks @Diggsey)
 
 # Simple example
 

examples/map.rs

@@ -34,11 +34,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map
         .insert("hi".to_string(), vec!["planet".to_string()]);
 
+    let mut hi_planet_hello_world = TestStruct::default();
+    hi_planet_hello_world
+        .map
+        .insert("hi".to_string(), vec!["planet".to_string()]);
+    hi_planet_hello_world
+        .map
+        .insert("hello".to_string(), vec!["world".to_string()]);
+
     let add_hello = serde_json::to_string(&Diff::serializable(&empty, &hello_world))?;
     let hello_to_hi = serde_json::to_string(&Diff::serializable(&hello_world, &hi_world))?;
     let add_planet = serde_json::to_string(&Diff::serializable(&hi_world, &hi_world_and_planet))?;
     let del_world = serde_json::to_string(&Diff::serializable(&hi_world_and_planet, &hi_planet))?;
     let no_change = serde_json::to_string(&Diff::serializable(&hi_planet, &hi_planet))?;
+    let add_world = serde_json::to_string(&Diff::serializable(&hi_planet, &hi_planet_hello_world))?;
 
     let mut built = TestStruct::default();
     for (diff, after) in &[
@@ -47,6 +56,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         (add_planet, hi_world_and_planet),
         (del_world, hi_planet.clone()),
         (no_change, hi_planet),
+        (add_world, hi_planet_hello_world),
     ] {
         println!("{}", diff);
 

examples/set.rs

@@ -0,0 +1,51 @@
+use serde::{Deserialize, Serialize};
+use serde_diff::{Apply, Diff, SerdeDiff};
+use std::collections::HashSet;
+
+#[derive(SerdeDiff, Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
+struct TestStruct {
+    test: bool,
+    //#[serde_diff(opaque)]
+    set: HashSet<String>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut empty = TestStruct::default();
+    empty.test = true;
+
+    let mut a = TestStruct::default();
+    a.set.insert("a".to_string());
+
+    let mut ab = TestStruct::default();
+    ab.set.insert("a".to_string());
+    ab.set.insert("b".to_string());
+
+    let mut b = TestStruct::default();
+    b.set.insert("b".to_string());
+
+    let mut c = TestStruct::default();
+    c.set.insert("c".to_string());
+
+    let add_a = serde_json::to_string(&Diff::serializable(&empty, &a))?;
+    let add_b = serde_json::to_string(&Diff::serializable(&a, &ab))?;
+    let del_a = serde_json::to_string(&Diff::serializable(&ab, &b))?;
+    let rep_b_c = serde_json::to_string(&Diff::serializable(&b, &c))?;
+    let no_change = serde_json::to_string(&Diff::serializable(&c, &c))?;
+
+    let mut built = TestStruct::default();
+    for (diff, after) in &[
+        (add_a, a),
+        (add_b, ab),
+        (del_a, b),
+        (rep_b_c, c.clone()),
+        (no_change, c),
+    ] {
+        println!("{}", diff);
+
+        let mut deserializer = serde_json::Deserializer::from_str(&diff);
+        Apply::apply(&mut deserializer, &mut built)?;
+
+        assert_eq!(after, &built);
+    }
+    Ok(())
+}

src/implementation.rs

@@ -7,7 +7,7 @@ use crate::{
 use serde::{de, ser::SerializeSeq, Deserialize, Serialize};
 
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     hash::Hash,
 };
 
@@ -237,6 +237,78 @@ macro_rules! map_serde_diff {
 map_serde_diff!(HashMap<K, V>, Hash, Eq);
 map_serde_diff!(BTreeMap<K, V>, Ord);
 
+/// Implement SerdeDiff on a "set-like" type such as HashSet.
+macro_rules! set_serde_diff {
+    ($t:ty, $($extra_traits:path),*) => {
+        impl<K> SerdeDiff for $t
+        where
+            K: SerdeDiff + Serialize + for<'a> Deserialize<'a> $(+ $extra_traits)*, // + Hash + Eq,
+        {
+            fn diff<'a, S: SerializeSeq>(
+                &self,
+                ctx: &mut $crate::difference::DiffContext<'a, S>,
+                other: &Self,
+            ) -> Result<bool, S::Error> {
+                use $crate::difference::DiffCommandRef;
+
+                let mut changed = false;
+
+                // TODO: detect renames
+                for key in self.iter() {
+                    if !other.contains(key) {
+                        ctx.save_command(&DiffCommandRef::RemoveKey(key), true, true)?;
+                        changed = true;
+                    }
+                }
+
+                for key in other.iter() {
+                    if !self.contains(key) {
+                        ctx.save_command(&DiffCommandRef::AddKey(key), true, true)?;
+                        changed = true;
+                    }
+                }
+
+                if changed {
+                    ctx.save_command::<()>(&DiffCommandRef::Exit, true, false)?;
+                }
+                Ok(changed)
+            }
+
+            fn apply<'de, A>(
+                &mut self,
+                seq: &mut A,
+                ctx: &mut ApplyContext,
+            ) -> Result<bool, <A as de::SeqAccess<'de>>::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                let mut changed = false;
+                while let Some(cmd) = ctx.read_next_command::<A, K>(seq)? {
+                    use $crate::difference::DiffCommandValue::*;
+                    use $crate::difference::DiffPathElementValue::*;
+                    match cmd {
+                        // we should not be getting fields when reading collection commands
+                        Enter(Field(_)) | EnterKey(_) => {
+                            ctx.skip_value(seq)?;
+                            break;
+                        }
+                        AddKey(key) => {
+                            self.insert(key);
+                            changed = true;
+                        }
+                        RemoveKey(key) => changed |= self.remove(&key),
+                        _ => break,
+                    }
+                }
+                Ok(changed)
+            }
+        }
+    };
+}
+
+set_serde_diff!(HashSet<K>, Hash, Eq);
+set_serde_diff!(BTreeSet<K>, Ord);
+
 /// Implements SerdeDiff on a type given that it impls Serialize + Deserialize + PartialEq.
 /// This makes the type a "terminal" type in the SerdeDiff hierarchy, meaning deeper inspection
 /// will not be possible. Use the SerdeDiff derive macro for recursive field inspection.