Making some sweaping changes

Author: RacecarBTF

CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.0
+- Re-writing such that there are no global variables, just partial private functions
+- Removing mixed map/vector merging
+- Adding a lot more testing
+
 ## 0.0.1
 - Adding the 'vector-blind-merge-with-dedupe' vector merge strategy
 - Adding the 'with-mixed-vector-map-merging' option

README.md

@@ -4,12 +4,21 @@ This acknowledge that merging could be simple or complex. Configuring merging sh
 
 You can use this library by adding it as a [dependency](https://github.com/technomancy/leiningen/blob/stable/doc/TUTORIAL.md#dependencies):
 
-**https://clojars.org/clojure-deep-merge** 
+[![Clojars Project](https://img.shields.io/clojars/v/clojure-deep-merge.svg)](https://clojars.org/clojure-deep-merge)
+
+## Usage
+At this point, merging is divided into 3 types of comparisons:
+* All maps - Handled with a recursive call using [`merge-with`](https://clojuredocs.org/clojure.core/merge-with)
+* All non-map collections - Most of what has been considered so far
+  * `concat-merge`/`concat-merge-with` - Puts all items into one vector
+  * `distinct-merge`/`distinct-merge-with` - Puts all items into one deduplicated vector
+  * `index-merge`/`index-merge-with` - Handled with recursive calls using all values at each index and puts the results in a vector
+* Other - For all functions that end with `-with` take a first parameter of a function that will handle these situations and all functions that do not use the value from the last argument passed in
 
 ## Merge Requests
 In order to make recommendations to this library, either please
 1. Fork this repository
-2. Create a branch (name it whatever you would like)
+2. Create a branch (name it whatever you would like) in your repository created in step 1
 3. Make your changes to that branch
 4. Run tests
 5. [Create a pull request from that branch of the forked repository to the master branch of this repository](https://help.github.com/articles/creating-a-pull-request-from-a-fork/). Check the following values when creating it (steps 4 & 5):
@@ -23,4 +32,4 @@ Or create an issue with specifics of what is wrong or what you would like to see
 ## Build Framework
 This incorporates [Leiningen](https://leiningen.org/) for its build/test/deploy process.
 ### Testing
-To test this project, run `lein test`
+To test this project, run `lein test`.

src/deep/merge.clj

@@ -1,72 +1,51 @@
 (ns deep.merge
   (:gen-class))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; These are variables needed for the main 'deep-merge' method of this project ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defonce ^:dynamic *vector-merge-method* nil)
-(defonce ^:dynamic *merge-mixed-vector-map-sets* false)
+(defn- deep-coll-merge-with
+  "The base method used for recursive collection merging"
+  [collection-merge-method non-collection-merge-method & vals]
+  (let [this-method (partial deep-coll-merge-with collection-merge-method non-collection-merge-method)]
+    (cond
+      (every? map? vals) (apply merge-with this-method vals)
+      (every? coll? vals) (apply collection-merge-method vals)
+      :else (apply non-collection-merge-method vals))))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; This is the main method that can be used by redefining the above variables ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defn deep-merge
-  "Based on the various environment variables in this namespace, merge two maps or vectors.
-  If a merge of the objects cannot happen, the last object is returned."
-  ([] nil)
-  ([& obj-args]
-   (cond
-     (every? map? obj-args) (apply merge-with deep-merge obj-args)
-     (every? vector? obj-args) (apply *vector-merge-method* obj-args)
-     (and *merge-mixed-vector-map-sets* (every? #(or (map? %) (vector? %)) obj-args)) (deep-merge (map #(if (map? %) [%] %)))
-     :always (last obj-args))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Collection Merge Methods ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn- concat-coll-merge
+  "Puts all items from all args blindly into one vector"
+  [& args]
+  (->> args
+       (apply concat)
+       (into [])))
+(defn- distinct-concat-coll-merge
+  "Puts all items from all args into one deduplicated vector"
+  [& args]
+  (->> args
+       (apply concat)
+       (distinct)
+       (into [])))
+(defn- index-coll-merge
+  "Looks at each index of all args and runs deep-coll-merge-with on all items at each index"
+  [non-collection-merge-method & args]
+  (let [max-index (apply max (map count args))
+        values-at-index (fn [index] (->> args
+                                         (filter #(< index (count %)))
+                                         (map #(nth % index))))
+        merge-index #(apply deep-coll-merge-with index-coll-merge non-collection-merge-method (values-at-index %))]
+    (->> (range 0 max-index)
+         (map merge-index)
+         (into []))))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; These methods define the various methods by which vectors can be merged ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defmacro with-vector-merge-method
-  "Adds a vector merge strategy to deep-merge."
-  [method & body]
-  `(binding [*vector-merge-method* ~method]
-     ~@body))
-(defn vector-blind-merge
-  "Blindly puts all vectors passed in into one vector.
-  If not all items are vectors, the last item is returned"
-  [& vectors]
-  (if (every? vector? vectors)
-    (apply concat vectors)
-    (last vectors)))
-(defn vector-index-merge
-  "Looks at each index across all vectors and runs deep-merge on that.
-  If not all items are vectors, the last item is returned."
-  [& vectors]
-  (if (every? vector? vectors)
-    (let [max-index (apply max (map count vectors))
-          get-all-indexes (fn [index] (filter
-                                        #(not (nil? %))
-                                        (map #(nth % index nil) vectors)))]
-      (for [i (range 0 max-index)] (apply deep-merge (get-all-indexes i))))
-    (last vectors)))
-(defn vector-blind-merge-with-dedupe
-  "Does the same thing as blind merge, but applies distinct to the resulting vector.
-  If not all items are vectors, the last item is returned."
-  [& vectors]
-  (if (every? vector? vectors)
-    (distinct (apply concat vectors))
-    (last vectors)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Additional options for 'deep-merge' ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defmacro with-mixed-vector-map-merging
-  "deep-merges within this macro will allow mixed sets of vectors/maps to be merged.
-  This happens by taking maps and putting them into the first index of new vectors.
-  After the conversion happens, deep merge is called again."
-  [& body]
-  `(binding [*merge-mixed-vector-map-sets* true]
-     ~@body))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Setting defaults for 'deep-merge' ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(alter-var-root (var *vector-merge-method*) (constantly vector-blind-merge))
+;;;;;;;;;;;;;;;;;;;;;
+;; Wrapper Methods ;;
+;;;;;;;;;;;;;;;;;;;;;
+(def concat-merge-with (partial deep-coll-merge-with concat-coll-merge))
+(def concat-merge (partial concat-merge-with #(last %&)))
+(def distinct-merge-with (partial deep-coll-merge-with distinct-concat-coll-merge))
+(def distinct-merge (partial distinct-merge-with #(last %&)))
+(defn- index-merge-with
+  [non-collection-merge-method & vals]
+  (apply deep-coll-merge-with (partial index-coll-merge non-collection-merge-method) non-collection-merge-method vals))
+(def index-merge (partial index-merge-with #(last %&)))

test/deep/merge_test.clj

@@ -2,40 +2,41 @@
   (:require [clojure.test :refer :all]
             [deep.merge :as sut]))
 
-(defn deep-merge-test
-  [description output & input]
-  (testing description (is (= output (apply sut/deep-merge input)))))
+(deftest test-concat-merge
+  (testing "Various expected outputs of `concat-merge`, given various inputs"
+    (are
+      [arg-list expected-output]
+      (= expected-output (apply sut/concat-merge arg-list))
+      [{:a :b} {:c :d}] {:a :b :c :d}
+      [{:a :b} {:a :d}] {:a :d}
+      [{:a [:b]} {:c [:d]}] {:a [:b] :c [:d]}
+      [{:a [:b :d]} {:c [:d]}] {:a [:b :d] :c [:d]}
+      [{:a [:b]} {:a [:d]}] {:a [:b :d]}
+      [{:a [:b :d]} {:a [:d]}] {:a [:b :d :d]}
+      [{:a [:b :c]} {:a [:d]}] {:a [:b :c :d]}
+      [{:a [:b]} {:a [:c]} {:a [:d]}] {:a [:b :c :d]}
+      [{:a [{:b :c}]} {:a [{:b :c}]}] {:a [{:b :c} {:b :c}]}
+      [{:a :b :c [:d]}] {:a :b :c [:d]}
+      [{:a :b :c [:d]} {:e :f} {:c [:e]}] {:a :b :c [:d :e] :e :f})))
 
-(deftest test-deep-merge
-  (deep-merge-test
-    "Can deep-merge be called without setting any strategies"
-    {:a :b, :c :d :e :f}
-    {:a :b} {:c :d} {:e :f})
-  (deep-merge-test
-    "Can deep-merge work if two values are passed in"
-    :b
-    :a :b))
-
-(deftest test-blind-merge
-  (sut/with-vector-merge-method
-    sut/vector-blind-merge
-    (deep-merge-test
-      "Can deep-merge merge two arrays"
-      [:a :b :c :d]
-      [:a :b] [:c :d])
-    (deep-merge-test
-      "Will deep merge keep all items of two arrays"
-      [:a :b :b :c]
-      [:a :b] [:b :c])
-    (deep-merge-test
-      "Does merging two arrays within two maps work well?"
-      {:a [{:b :c} {:d :e} {:b :d} {:e :d}]}
-      {:a [{:b :c} {:d :e}]} {:a [{:b :d} {:e :d}]})))
+(deftest test-distinct-merge
+  (testing "Various expected outputs of `distinct-merge`, given various inputs"
+    (are
+      [arg-list expected-output]
+      (= expected-output (apply sut/distinct-merge arg-list))
+      [{:a :b} {:c :d}] {:a :b :c :d}
+      [{:a :b} {:a :d}] {:a :d}
+      [{:a [:b]} {:c [:d]}] {:a [:b] :c [:d]}
+      [{:a [{:b :c}]} {:a [{:b :c}]}] {:a [{:b :c}]}
+      [{:a [:b :d]} {:a [:d]}] {:a [:b :d]})))
 
 (deftest test-index-merge
-  (sut/with-vector-merge-method
-    sut/vector-index-merge
-    (deep-merge-test
-      "Will deep merge keep all items of two arrays"
-      [:b :c]
-      [:a :b] [:b :c])))
+  (testing "Various expected outputs of `index-merge`, given various inputs"
+    (are
+      [arg-list expected-output]
+      (= expected-output (apply sut/index-merge arg-list))
+      [{:a :b} {:c :d}] {:a :b :c :d}
+      [{:a :b} {:a :d}] {:a :d}
+      [{:a [:b]} {:c [:d]}] {:a [:b] :c [:d]}
+      [{:a [{:b :c}]} {:a [{:b :c}]}] {:a [{:b :c}]}
+      [{:a [:b :d]} {:a [:d]}] {:a [:d :d]})))