Fix the issue with matching objects

Author: ksceriath

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "json_diff"
 version = "0.1.0"
-authors = ["Kshitij Tyagi <tkshitij@thoughtworks.com>"]
+authors = ["ksceriath"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/main.rs

@@ -35,25 +35,22 @@ fn main() {
     let value: Value = serde_json::from_str(data).unwrap();
     let value2: Value = serde_json::from_str(data2).unwrap();
 
-    if value == value2 {
-        println!("JSONs match.");
-    } else {
-        match match_json(&value, &value2) {
-            Mismatch::NoMismatch => println!("No mismatch was found."),
-            Mismatch::ValueMismatch => println!("Mismatch at root."),
-            Mismatch::ObjectMismatch(a,b,c) => {
-                if let Some(left_keys) = a {
-                    println!("Following keys were not found in second object: {:?}", left_keys);
-                }
-                if let Some(right_keys) = b {
-                    println!("Following keys were not found in first object: {:?}", right_keys);
-                }
-                if let Some(unequal_keys) = c {
-                    println!("Following keys were not found to be equal: {:?}", unequal_keys);
-                }
+    match match_json(&value, &value2) {
+        Mismatch::NoMismatch => println!("No mismatch was found."),
+        Mismatch::ValueMismatch => println!("Mismatch at root."),
+        Mismatch::ObjectMismatch(None, None, None) => println!("No mismatch was found."),
+        Mismatch::ObjectMismatch(a,b,c) => {
+            if let Some(left_keys) = a {
+                println!("Following keys were not found in second object: {:?}", left_keys);
             }
-        };
-    }
+            if let Some(right_keys) = b {
+                println!("Following keys were not found in first object: {:?}", right_keys);
+            }
+            if let Some(unequal_keys) = c {
+                println!("Following keys were not found to be equal: {:?}", unequal_keys);
+            }
+        }
+    };
 }
 
 #[derive(Eq, PartialEq, Ord, PartialOrd, Debug)]
@@ -62,6 +59,7 @@ struct KeyMap {
     children: Option<BTreeSet<KeyMap>>,
 }
 
+#[derive(Debug)]
 enum Mismatch {
     NoMismatch,
     ValueMismatch,
@@ -72,34 +70,35 @@ fn match_json(value: &Value, value1: &Value) -> Mismatch {
     match (value, value1) {
         (Value::Object(a), Value::Object(b)) => {
             let (left, right, intersection) = intersect_maps(&a, &b);
-            let mut unequal_keys = BTreeSet::new();
+            let mut unequal_keys = None;
 
-            let mut left = left.iter().map(|x| KeyMap{ key: String::from(x), children: None }).collect::<BTreeSet<KeyMap>>();
-            let mut right = right.iter().map(|x| KeyMap{ key: String::from(x), children: None }).collect::<BTreeSet<KeyMap>>();
+            let mut left = left.map(|l| l.iter().map(|x| KeyMap{ key: String::from(x), children: None }).collect::<BTreeSet<KeyMap>>());
+            let mut right = right.map(|r| r.iter().map(|x| KeyMap{ key: String::from(x), children: None }).collect::<BTreeSet<KeyMap>>());
 
-            for key in intersection {
-                let x = match_json(&a.get(&key).unwrap(), &b.get(&key).unwrap());
-                if let Some(keys) = match x {
-                    Mismatch::NoMismatch => None,
-                    Mismatch::ValueMismatch => Some(KeyMap{ key, children: None }),
-                    Mismatch::ObjectMismatch(left_keys, right_keys, mismatch_keys) => {
-                        if let Some(left_keys) = left_keys {
-                            left.insert(KeyMap{ key: String::from(&key), children: Some(left_keys) });
-                        }
-                        if let Some(right_keys) = right_keys {
-                            right.insert(KeyMap{ key: String::from(&key), children: Some(right_keys) });
-                        }
-                        if let Some(mismatch_keys) = mismatch_keys {
-                            Some(KeyMap{ key: String::from(&key), children: Some(mismatch_keys) })
-                        } else {
-                            None
-                        }
-                    },
-                } {
-                    unequal_keys.insert(keys);
+            if let Some(intersection) = intersection {
+                for key in intersection {
+                    if let Some(keys) = match match_json(&a.get(&key).unwrap(), &b.get(&key).unwrap()) {
+                        Mismatch::NoMismatch => None,
+                        Mismatch::ValueMismatch => Some(KeyMap{ key, children: None }),
+                        Mismatch::ObjectMismatch(left_keys, right_keys, mismatch_keys) => {
+                            if let Some(left_keys) = left_keys {
+                                left.get_or_insert(BTreeSet::new()).insert(KeyMap{ key: String::from(&key), children: Some(left_keys) });
+                            }
+                            if let Some(right_keys) = right_keys {
+                                right.get_or_insert(BTreeSet::new()).insert(KeyMap{ key: String::from(&key), children: Some(right_keys) });
+                            }
+                            if let Some(mismatch_keys) = mismatch_keys {
+                                Some(KeyMap{ key: String::from(&key), children: Some(mismatch_keys) })
+                            } else {
+                                None
+                            }
+                        },
+                    } {
+                        unequal_keys.get_or_insert(BTreeSet::new()).insert(keys);
+                    }
                 }
             }
-            Mismatch::ObjectMismatch(Some(left), Some(right), Some(unequal_keys))
+            Mismatch::ObjectMismatch(left, right, unequal_keys)
         },
         (a, b) => {
             if a == b {
@@ -112,8 +111,8 @@ fn match_json(value: &Value, value1: &Value) -> Mismatch {
 }
 
 fn intersect_maps<'a>(a: &Map<String, Value>, 
-    b: &Map<String, Value>) -> (BTreeSet<String>,
-    BTreeSet<String>, BTreeSet<String>) {
+    b: &Map<String, Value>) -> (Option<BTreeSet<String>>,
+    Option<BTreeSet<String>>, Option<BTreeSet<String>>) {
     let mut intersection = BTreeSet::new();
     let mut left = BTreeSet::new();
     let mut right = BTreeSet::new();
@@ -129,5 +128,8 @@ fn intersect_maps<'a>(a: &Map<String, Value>,
             right.insert(String::from(b_key));
         }
     }
+    let left = if left.len() == 0 { None } else { Some(left) };
+    let right = if right.len() == 0 { None } else { Some(right) };
+    let intersection = if intersection.len() == 0 { None } else { Some(intersection) };
     (left, right, intersection)
 }