CLJ-719: call correct diff function for arrays as first argument

Signed-off-by: Stuart Halloway <stu@thinkrelevance.com>

src/clj/clojure/data.clj

@@ -12,6 +12,8 @@
   clojure.data
   (:require [clojure.set :as set]))
 
+(declare diff)
+
 (defn- atom-diff
   "Internal helper for diff."
   [a b]
@@ -28,7 +30,23 @@
      (vec (repeat (apply max (keys m))  nil))
      m)))
 
-(declare diff)
+(defn- diff-associative
+  "Diff associative things a and b, comparing only keys in ks."
+  [a b ks]
+  (reduce
+   (fn [diff1 diff2]
+     (map merge diff1 diff2))
+   [nil nil nil]
+   (map
+    (fn [k] (map #(when % {k %}) (diff (get a k) (get b k))))
+    ks)))
+
+(defn- diff-sequential
+  [a b]
+  (vec (map vectorize (diff-associative
+                       (if (vector? a) a (vec a))
+                       (if (vector? b) b (vec b))
+                       (range (max (count a) (count b)))))))
 
 (defprotocol ^{:added "1.3"} EqualityPartition
   "Implementation detail. Subject to change."
@@ -44,21 +62,10 @@
 
 (extend Object
         Diff
-        {:diff-similar atom-diff}
+        {:diff-similar (fn [a b] ((if (.. a getClass isArray) diff-sequential atom-diff) a b))}
         EqualityPartition
         {:equality-partition (fn [x] (if (.. x getClass isArray) :sequential :atom))})
 
-(defn- diff-associative
-  "Diff associative things a and b, comparing only keys in ks."
-  [a b ks]
-  (reduce
-   (fn [diff1 diff2]
-     (map merge diff1 diff2))
-   [nil nil nil]
-   (map
-    (fn [k] (map #(when % {k %}) (diff (get a k) (get b k))))
-    ks)))
-
 (extend-protocol EqualityPartition
   nil
   (equality-partition [x] :atom)
@@ -88,10 +95,7 @@
 
   java.util.List
   (diff-similar [a b]
-    (vec (map vectorize (diff-associative
-                         (if (vector? a) a (vec a))
-                         (if (vector? b) b (vec b))
-                         (range (max (count a) (count b)))))))
+    (diff-sequential a b))
 
   java.util.Map
   (diff-similar [a b]

test/clojure/test_clojure/data.clj

@@ -24,6 +24,8 @@
        [#{:a} #{:b} #{:c :d}] #{:a :c :d} #{:b :c :d}
        [nil nil {:a 1}] {:a 1} {:a 1}
        [{:a #{2}} {:a #{4}} {:a #{3}}] {:a #{2 3}} {:a #{3 4}}
-       [#{1} #{3} #{2}] (HashSet. [1 2]) (HashSet. [2 3]) 
+       [#{1} #{3} #{2}] (HashSet. [1 2]) (HashSet. [2 3])
+       [nil nil [1 2]] [1 2] (into-array [1 2])
+       [nil nil [1 2]] (into-array [1 2]) [1 2]
        [{:a {:c [1]}} {:a {:c [0]}} {:a {:c [nil 2] :b 1}}] {:a {:b 1 :c [1 2]}} {:a {:b 1 :c [0 2]}}))