Fix nil issue

Author: Daniel Neal

CHANGELOG.md

@@ -1,4 +1,8 @@
 # Change Log
+## [2019.10.04]
+### Fixed
+- Don't terminate loops early if there's a nil in a sequence
+
 ## [2019.09.14]
 
 ### New Major Version

README.md

@@ -225,16 +225,16 @@ Like a one-to-one index except that a nested hash-map of `path* -> item` is main
  - `id` - the id for the index in the compound
 
 ```clojure
-(-> (compound [{:index-type :one-to-one
-                :id :delivery
-                :kfn (juxt :customer :delivery-date :product)}
-               {:index-type :nested-to-one
-                :path [:customer :delivery-date :product]}])
-    (add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
-                {:customer 1 :delivery-date "2012-03-03" :product :apples}
-                {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
-                {:customer 2 :delivery-date "2012-03-04" :product :bananas}
-                {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
+(-> (c/compound [{:index-type :one-to-one
+                  :id :delivery
+                  :kfn (juxt :customer :delivery-date :product)}
+                 {:index-type :nested-to-one
+                  :path [:customer :delivery-date :product]}])
+    (c/add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
+                  {:customer 1 :delivery-date "2012-03-03" :product :apples}
+                  {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
+                  {:customer 2 :delivery-date "2012-03-04" :product :bananas}
+                  {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
 ;; => {:delivery
 ;;     {[1 "2012-03-03" :bananas]
 ;;      {:customer 1, :delivery-date "2012-03-03", :product :bananas},
@@ -291,16 +291,16 @@ Like a one-to-one index except that a nested hash-map of `path* -> item` is main
 ;;       {:potatoes
 ;;        {:customer 2, :delivery-date "2012-03-11", :product :potatoes}}}}};; =>
 
-(-> (compound [{:index-type :one-to-one
-                :id :delivery
-                :kfn (juxt :customer :delivery-date :product)}
-               {:index-type :nested-to-many
-                :path [:customer :delivery-date]}])
-    (add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
-                {:customer 1 :delivery-date "2012-03-03" :product :apples}
-                {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
-                {:customer 2 :delivery-date "2012-03-04" :product :bananas}
-                {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
+(-> (c/compound [{:index-type :one-to-one
+                  :id :delivery
+                  :kfn (juxt :customer :delivery-date :product)}
+                 {:index-type :nested-to-many
+                  :path [:customer :delivery-date]}])
+    (c/add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
+                  {:customer 1 :delivery-date "2012-03-03" :product :apples}
+                  {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
+                  {:customer 2 :delivery-date "2012-03-04" :product :bananas}
+                  {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
 ```
 
 ### Index type: nested-to-many
@@ -314,16 +314,16 @@ Like a one-to-many index except that a nested hash-map is `path* -> set` is main
  - `id` - the id for the index in the compound
 
 ``` clojure
-(-> (compound [{:index-type :one-to-one
-                :id :delivery
-                :kfn (juxt :customer :delivery-date :product)}
-               {:index-type :nested-to-many
-                :path [:customer :delivery-date]}])
-    (add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
-                {:customer 1 :delivery-date "2012-03-03" :product :apples}
-                {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
-                {:customer 2 :delivery-date "2012-03-04" :product :bananas}
-                {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
+(-> (c/compound [{:index-type :one-to-one
+                  :id :delivery
+                  :kfn (juxt :customer :delivery-date :product)}
+                 {:index-type :nested-to-many
+                  :path [:customer :delivery-date]}])
+    (c/add-items [{:customer 1 :delivery-date "2012-03-03" :product :bananas}
+                  {:customer 1 :delivery-date "2012-03-03" :product :apples}
+                  {:customer 1 :delivery-date "2012-03-10" :product :potatoes}
+                  {:customer 2 :delivery-date "2012-03-04" :product :bananas}
+                  {:customer 2 :delivery-date "2012-03-11" :product :potatoes}]))
 ;; => {:delivery
 ;;     {[1 "2012-03-03" :bananas]
 ;;      {:customer 1, :delivery-date "2012-03-03", :product :bananas},

project.clj

@@ -1,4 +1,4 @@
-(defproject riverford/compound "2019.09.14"
+(defproject riverford/compound "2019.10.04"
   :description "A micro structure for reagent data"
   :url "https://github.com/riverford/compound"
   :license {:name "Eclipse Public License"

src/compound2/core.cljc

@@ -177,14 +177,8 @@
                                           (assoc acc si (before si (get c (id si)))))
                                         {}
                                         sis)
-                           [x & xs] xs]
-                      (if (nil? x)
-                        (with-meta
-                          (reduce-kv (fn [acc si sx]
-                                       (assoc acc (id si) (after si sx)))
-                                     {(id pi) (after pi px)}
-                                     sixs)
-                          (meta c))
+                           [x & more :as xs] xs]
+                      (if (seq xs)
                         (let [k (extract-key pi x)
                               ex (get-by-key pi px k)]
                           (if ex
@@ -196,37 +190,43 @@
                                                                   (index si (unindex si sx k1 ex) k2 new))))
                                                 {}
                                                 sixs)
-                                     xs))
+                                     more))
                             (recur (index pi px k x)
                                    (reduce-kv (fn [acc si sx]
                                                 (assoc acc si (let [k (extract-key si x)]
                                                                 (index si sx k x))))
                                               {}
                                               sixs)
-                                   xs))))))
+                                   more)))
+                        (with-meta
+                          (reduce-kv (fn [acc si sx]
+                                       (assoc acc (id si) (after si sx)))
+                                     {(id pi) (after pi px)}
+                                     sixs)
+                          (meta c)))))
        `remove-keys (fn [c ks]
                       (loop [px (before pi (get c (id pi)))
                              sixs (reduce (fn [acc si]
                                             (assoc acc si (before si (get c (id si)))))
                                           {}
                                           sis)
-                             [k & ks] ks]
-                        (if (nil? k)
-                          (with-meta
-                            (reduce-kv (fn [acc si sx]
-                                         (assoc acc (id si) (after si sx)))
-                                       {(id pi) (after pi px)}
-                                       sixs)
-                            (meta c))
+                             [k & more :as ks] ks]
+                        (if (seq ks)
                           (if-let [ex (get-by-key pi px k)]
                             (recur (unindex pi px k ex)
                                    (reduce-kv (fn [acc si sx]
                                                 (assoc acc si (let [k (extract-key si ex)]
                                                                 (unindex si sx k ex))))
                                               {}
                                               sixs)
-                                   ks)
-                            (recur px sixs ks)))))})))
+                                   more)
+                            (recur px sixs more))
+                          (with-meta
+                            (reduce-kv (fn [acc si sx]
+                                         (assoc acc (id si) (after si sx)))
+                                       {(id pi) (after pi px)}
+                                       sixs)
+                            (meta c)))))})))
 
 #?(:clj
    (defmacro compound [indexes]
@@ -257,15 +257,8 @@
                                              [sx `(before ~si (get ~m-sym (id ~si)))])
                                            si-syms
                                            sx-syms)
-                                 [~x-sym & xs#] xs#]
-                            (if (nil? ~x-sym)
-                              (with-meta ~(into {`(id ~pi-sym) `(after ~pi-sym ~px-sym)}
-                                                (map (fn [si sx]
-                                                       [`(id ~si)
-                                                        `(after ~si ~sx)])
-                                                     si-syms
-                                                     sx-syms))
-                                (meta ~m-sym))
+                                 [~x-sym & more# :as xs#] xs#]
+                            (if (seq xs#)
                               (let [k# (extract-key ~pi-sym ~x-sym)
                                     ~ex-sym (get-by-key ~pi-sym ~px-sym k#)]
                                 (if ~ex-sym
@@ -278,30 +271,30 @@
                                                   (index ~si (unindex ~si ~sx k1# ~ex-sym) k2# ~new-sym)))
                                              si-syms
                                              sx-syms)
-                                      xs#))
+                                      more#))
                                   (recur
                                     (index ~pi-sym ~px-sym k# ~x-sym)
                                     ~@(map (fn [si sx]
                                              `(let [k# (extract-key ~si ~x-sym)]
                                                 (index ~si ~sx k# ~x-sym)))
                                            si-syms
                                            sx-syms)
-                                    xs#))))))
+                                    more#)))
+                              (with-meta ~(into {`(id ~pi-sym) `(after ~pi-sym ~px-sym)}
+                                                (map (fn [si sx]
+                                                       [`(id ~si)
+                                                        `(after ~si ~sx)])
+                                                     si-syms
+                                                     sx-syms))
+                                (meta ~m-sym)))))
              `remove-keys (fn [~m-sym ks#]
                             (loop [~px-sym (before ~pi-sym (get ~m-sym (id ~pi-sym)))
                                    ~@(mapcat (fn [si sx]
                                                [sx `(before ~si (get ~m-sym (id ~si)))])
                                              si-syms
                                              sx-syms)
-                                   [~k-sym & ks#] ks#]
-                              (if (nil? ~k-sym)
-                                (with-meta ~(into {`(id ~pi-sym) `(after ~pi-sym ~px-sym)}
-                                                  (map (fn [si sx]
-                                                         [`(id ~si)
-                                                          `(after ~si ~sx)])
-                                                       si-syms
-                                                       sx-syms))
-                                  (meta ~m-sym))
+                                   [~k-sym & more# :as ks#] ks#]
+                              (if (seq ks#)
                                 (if-let [~ex-sym (get-by-key ~pi-sym ~px-sym ~k-sym)]
                                   (recur
                                     (unindex ~pi-sym ~px-sym ~k-sym ~ex-sym)
@@ -310,8 +303,15 @@
                                                 (unindex ~si ~sx k# ~ex-sym)))
                                            si-syms
                                            sx-syms)
-                                    ks#)
+                                    more#)
                                   (recur
                                     ~px-sym
                                     ~@sx-syms
-                                    ks#)))))})))))
+                                    more#))
+                                (with-meta ~(into {`(id ~pi-sym) `(after ~pi-sym ~px-sym)}
+                                                  (map (fn [si sx]
+                                                         [`(id ~si)
+                                                          `(after ~si ~sx)])
+                                                       si-syms
+                                                       sx-syms))
+                                  (meta ~m-sym)))))})))))

test/compound2/test.cljc

@@ -167,33 +167,23 @@
                            :index-type :one-to-one}])
              (c/add-items [{:id 1 :name "Bob"} {:id 2 :name "Terry"} {:id 3 :name "Squirrek"} {:id 3 :color :red}])))))
 
-(-> (c/compound [{:id :by-name ;; defaults to :kfn if :id not provided
-                  :index-type :one-to-one ;; defaults to :one-to-one for primary index
-                  :kfn :name
-                  :on-conflict (fn [a b] (merge a b))}
-                 {:id :by-colour
-                  :index-type :one-to-many ;; defaults to :one-to-many for secondary index
-                  :kfn :colour}
-                 {:id :by-tastiness
-                  :index-type :one-to-many ;; defaults to :one-to-many for secondary index
-                  :kfn :tastiness}])
-
-    (c/add-items [{:name :strawberry
-                   :colour :red
-                   :tastiness 4}
-
-                  {:name :strawberry
-                   :tastiness 5}
-
-                  {:name :banana
-                   :tastiness 3
-                   :colour :yellow}]))
-;; => {:by-name
-;;     {:strawberry {:name :strawberry, :colour :red, :tastiness 5},
-;;      :banana {:name :banana, :tastiness 3, :colour :yellow}},
-;;     :by-colour
-;;     {:red #{{:name :strawberry, :colour :red, :tastiness 5}},
-;;      :yellow #{{:name :banana, :tastiness 3, :colour :yellow}}},
-;;     :by-tastiness
-;;     {5 #{{:name :strawberry, :colour :red, :tastiness 5}},
-;;      3 #{{:name :banana, :tastiness 3, :colour :yellow}}}}
+(deftest dont-terminate-early-on-nil
+  []
+  (is (= {:name
+          {"Terry" {:id 2, :name "Terry"},
+           "Squirrel" {:id 3, :name "Squirrel"},
+           "Bob" {:id 1, :name "Bob"}},
+          :id
+          {1 {:id 1, :name "Bob"},
+           2 {:id 2, :name "Terry"},
+           3 {:id 3, :name "Squirrel"}}}
+         (-> (c/compound [{:index-type :one-to-one
+                           :kfn :id}
+                          {:index-type :one-to-one
+                           :kfn :name}])
+             (c/add-items [{:id 1 :name "Bob"}  nil {:id 2 :name "Terry"} nil {:id 3 :name "Squirrel"}]))
+         (-> (c/compound* [{:index-type :one-to-one
+                            :kfn :id}
+                           {:index-type :one-to-one
+                            :kfn :name}])
+             (c/add-items [{:id 1 :name "Bob"} nil {:id 2 :name "Terry"} nil {:id 3 :name "Squirrel"}])))))