fix error in related to direct-bindings

did not exit bindings loop correctly and "matched" empty bindings instead

src/cuphic/core.cljc

@@ -126,7 +126,9 @@
               (cond
                 (= k v) kvs
                 (symbol? k) (conj kvs kv)
-                (vector? v) (apply conj kvs (bindings-delta k v))
+                (vector? v) (if-let [delta (bindings-delta k v)]
+                              (apply conj kvs delta)
+                              (reduced nil))
                 :else (reduced nil)))
             []
             (map vector capture-pattern nodes))))
@@ -194,10 +196,11 @@
         (when (<= min-count (count hnodes))
           (case quantifier
             ;; With no quantifier, we simply capture the direct bindings.
-            nil (let [bound   (subvec hnodes 0 min-count)
-                      unbound (subvec hnodes min-count)
-                      ret*    (into ret (direct-bindings pattern bound))]
-                  (recur ret* unbound patterns))
+            nil (let [bound     (subvec hnodes 0 min-count)
+                      unbound   (subvec hnodes min-count)
+                      dbindings (direct-bindings pattern bound)]
+                  (when dbindings
+                    (recur (into ret dbindings) unbound patterns)))
 
             :prefix (let [[[quantifier] after] parts
                           bound   (nodes-until next-pattern hnodes min-count)

test/cuphic/core_test.cljc

@@ -282,7 +282,16 @@
                    [:span {:id "b"}]]]
                  '[?tag {:id "nada"}]
                  '[:span {:id ?id}]
-                 '[?tag {:id ?id}]))))
+                 '[?tag {:id ?id}]))
+
+        (testing "should return only nil bindings for no matches"
+          (let [actual (scan [:div {}
+                              [:p {:id "p"}
+                               [:span {:id "span"}]]]
+
+                             '[:div {} [:p {:id "nada"}]])]
+            (is (every? vector? (map first actual)))
+            (is (every? nil? (map second actual)))))))
 
   (testing "scraping a Hiccup tree"
     (let [actual (scrape [:div {}
@@ -298,7 +307,15 @@
                :y [{?id "b"}]}
              actual))
 
-      (testing "scrape includes metadata for the zipper loc"
+      (testing "should return an empty map when no bindings are found"
+        (is (= {}
+               (scrape [:div {}
+                        [:p {:id "p"}
+                         [:span {:id "span"}]]]
+
+                       {:nada '[:div {} [:p {:id "nada"}]]}))))
+
+      (testing "should include metadata containing zipper locs"
         (let [locs (->> (vals actual)
                         (apply concat)
                         (map (comp :loc meta)))