Fix struct-in-map diffing

Author: Diggsey

Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "serde-diff"
 version = "0.4.1"
-authors = ["Karl Bergström <[email protected]>", "Philip Degarmo <[email protected]>"]
+authors = [
+    "Karl Bergström <[email protected]>",
+    "Philip Degarmo <[email protected]>",
+]
 readme = "README.md"
 exclude = ["examples/*"]
 license = "Apache-2.0 OR MIT"
@@ -17,10 +20,11 @@ maintenance = { status = "experimental" }
 
 [dependencies]
 serde-diff-derive = { version = "0.4.0", path = "serde-diff-derive" }
-serde =  { version = "1", features = [ "derive" ] }
-serde_derive = { version = "1", features = ["deserialize_in_place"]}
+serde = { version = "1", features = ["derive"] }
+serde_derive = { version = "1", features = ["deserialize_in_place"] }
 
 [dev-dependencies]
 serde_json = "1.0"
 bincode = "1.2"
 rmp-serde = "0.15.0"
+maplit = "1.0.2"

src/difference.rs

@@ -27,7 +27,7 @@ pub struct DiffContext<'a, S: SerializeSeq> {
     /// Mode for serializing field paths
     field_path_mode: FieldPathMode,
     /// Set to true if any change is detected
-    has_changes: bool,
+    has_changes: &'a mut bool,
 }
 
 impl<'a, S: SerializeSeq> Drop for DiffContext<'a, S> {
@@ -52,7 +52,7 @@ impl<'a, S: SerializeSeq> DiffContext<'a, S> {
 
     /// True if a change operation has been written
     pub fn has_changes(&self) -> bool {
-        self.has_changes
+        *self.has_changes
     }
 
     /// Called when we visit a field. If the structure is recursive (i.e. struct within struct,
@@ -186,7 +186,7 @@ impl<'a, S: SerializeSeq> DiffContext<'a, S> {
             }
             self.element_stack_start = 0;
         }
-        self.has_changes |= is_change;
+        *self.has_changes |= is_change;
         self.implicit_exit_written = implicit_exit;
         self.serializer.serialize_element(value)
     }
@@ -225,7 +225,7 @@ impl<'a, S: SerializeSeq> DiffContext<'a, S> {
             serializer: &mut *self.serializer,
             implicit_exit_written: self.implicit_exit_written,
             field_path_mode: self.field_path_mode,
-            has_changes: false,
+            has_changes: self.has_changes,
         }
     }
 }
@@ -294,7 +294,7 @@ impl<'a, 'b, T: SerdeDiff> Serialize for Diff<'a, 'b, T> {
                     implicit_exit_written: false,
                     parent_element_stack: None,
                     field_path_mode: self.field_path_mode,
-                    has_changes: false,
+                    has_changes: &mut false,
                 };
                 self.old.diff(&mut ctx, &self.new).unwrap();
             }
@@ -314,13 +314,13 @@ impl<'a, 'b, T: SerdeDiff> Serialize for Diff<'a, 'b, T> {
                 implicit_exit_written: false,
                 parent_element_stack: None,
                 field_path_mode: self.field_path_mode,
-                has_changes: false,
+                has_changes: &mut false,
             };
 
             // Do the actual comparison, writing diff commands (see DiffCommandRef, DiffCommandValue)
             // into the sequence
             self.old.diff(&mut ctx, &self.new)?;
-            self.has_changes.set(ctx.has_changes);
+            self.has_changes.set(*ctx.has_changes);
         }
 
         // End the sequence on the serializer

src/implementation.rs

@@ -172,25 +172,23 @@ macro_rules! map_serde_diff {
                             if <V as SerdeDiff>::diff(self_value, &mut subctx, other_value)? {
                                 changed = true;
                             }
+                            subctx.pop_path_element()?;
                         },
                         None => {
-                            ctx.save_command(&DiffCommandRef::RemoveKey(key), true, true)?;
+                            ctx.save_command(&DiffCommandRef::RemoveKey(key), false, true)?;
                             changed = true;
                         },
                     }
                 }
 
                 for (key, other_value) in other.iter() {
                     if !self.contains_key(key) {
-                        ctx.save_command(&DiffCommandRef::AddKey(key), true, true)?;
-                        ctx.save_command(&DiffCommandRef::Value(other_value), true, true)?;
+                        ctx.save_command(&DiffCommandRef::AddKey(key), false, true)?;
+                        ctx.save_command(&DiffCommandRef::Value(other_value), false, true)?;
                         changed = true;
                     }
                 }
 
-                if changed {
-                    ctx.save_command::<()>(&DiffCommandRef::Exit, true, false)?;
-                }
                 Ok(changed)
             }
 
@@ -268,9 +266,6 @@ macro_rules! set_serde_diff {
                     }
                 }
 
-                if changed {
-                    ctx.save_command::<()>(&DiffCommandRef::Exit, true, false)?;
-                }
                 Ok(changed)
             }