Improve handling for sets and maps

Make sure we don't report a difference when there is none. For sets the issue
came from handling them as ordered collections when they aren't, with maps we
had a case of using sets as predicates, which breaks when one of the elements is
false or null.

Closes #43

Author: plexus

src/lambdaisland/deep_diff2/diff_impl.cljc

@@ -97,11 +97,31 @@
          (diff-seq-insertions ins)
          (into []))))
 
+(defn diff-set [exp act]
+  (into
+   (into #{}
+         (map (fn [e]
+                (if (contains? act e)
+                  e
+                  (->Deletion e))))
+         exp)
+   (map ->Insertion)
+   (remove #(contains? exp %) act)))
+
+(let [exp {false 0, 0 0}
+      act {false 0, 0 0}
+      exp-ks (keys exp)
+      act-ks (concat (filter #(contains? (set (keys act)) %) exp-ks)
+                     (remove #(contains? (set exp-ks) %) (keys act)))
+      [del ins] (del+ins exp-ks act-ks)]
+  [del ins])
+(del+ins [0 false] [0 false])
+
 (defn diff-map [exp act]
   (first
    (let [exp-ks (keys exp)
-         act-ks (concat (filter (set (keys act)) exp-ks)
-                        (remove (set exp-ks) (keys act)))
+         act-ks (concat (filter #(contains? (set (keys act)) %) exp-ks)
+                        (remove #(contains? (set exp-ks) %) (keys act)))
          [del ins] (del+ins exp-ks act-ks)]
      (reduce
       (fn [[m idx] k]
@@ -162,10 +182,7 @@
 (extend-protocol Diff
   #?(:clj java.util.Set :cljs cljs.core/PersistentHashSet)
   (-diff-similar [exp act]
-    (let [exp-seq (seq exp)
-          act-seq (seq act)]
-      (set (diff-seq exp-seq (concat (filter act exp-seq)
-                                     (remove exp act-seq))))))
+    (diff-set exp act))
   #?@(:clj
       [java.util.List
        (-diff-similar [exp act] (diff-seq exp act))

test/lambdaisland/deep_diff2/diff_test.cljc

@@ -212,10 +212,16 @@
                          (gen/such-that (complement NaN?) gen/simple-type)))
 
 (defspec round-trip-diff 100
-  (prop/for-all [x gen-any-except-NaN
-                 y gen-any-except-NaN]
-    (let [diff (diff/diff x y)]
-      (= [x y] [(diff/left-undiff diff) (diff/right-undiff diff)]))))
+  (prop/for-all
+   [x gen-any-except-NaN
+    y gen-any-except-NaN]
+   (let [diff (diff/diff x y)]
+     (= [x y] [(diff/left-undiff diff) (diff/right-undiff diff)]))))
+
+(defspec diff-same-is-same 100
+  (prop/for-all
+   [x gen-any-except-NaN]
+   (= x (diff/diff x x))))
 
 (deftest diff-seq-test
   (is (= [(diff/->Insertion 1) 2 (diff/->Insertion 3)]

test/lambdaisland/deep_diff2/manipulate_test.cljc

@@ -70,11 +70,10 @@
              [])))))
 
 ;; "diff itself and remove-unchanged yields empty"
-(comment
- (defspec diff-itself 100
-  (prop/for-all [x diff-test/gen-any-except-NaN]
-                (if (coll? x)
-                  (= (manipulate/remove-unchanged (ddiff/diff x x))
-                     (empty x))
-                  (= (manipulate/remove-unchanged (ddiff/diff x x))
-                     nil)))))
+(defspec diff-itself 100
+  (prop/for-all
+   [x diff-test/gen-any-except-NaN]
+   (if (coll? x)
+     (= (manipulate/remove-unchanged (ddiff/diff x x))
+        (empty x))
+     (nil? (manipulate/remove-unchanged (ddiff/diff x x))))))