support literal true and false in boolean expressions

Author: oakmac

src/json_path/walker.clj

@@ -7,12 +7,32 @@
   (and (map? m)
        (contains? m :value)))
 
-;; NOTE: this function produces a runtime error when comparing things of different types
-;; ie: (< 3 "foo")
-;; Will need to coerce the types in order to get the "Filter expression with boolean or operator and value false"
-;; test case to pass
+;; 'and' and 'or' are macros in Clojure, so we wrap them in functions here so they
+;; can be passed to apply and tested for equality
+(defn and* [a b]
+  (and a b))
+
+(defn or* [a b]
+  (or a b))
+
 (defn eval-bool-expr [comp-fn context operands]
-  (boolean (apply comp-fn (map #(eval-expr % context) operands))))
+  (boolean
+    (apply
+      (fn [a b]
+        (cond
+          ;; allow less-than, greater-than comparisons if both args are Numbers or Strings
+          (and (contains? #{< <= > >=} comp-fn)
+               (or (and (number? a) (number? b))
+                   (and (string? a) (string? b))))
+          (comp-fn a b)
+
+          ;; always allow equality comparisons as well as 'and' and 'or'
+          (contains? #{= not= and* or*} comp-fn)
+          (comp-fn a b)
+
+          ;; else the two values cannot be compared: return false
+          :else false))
+      (map #(eval-expr % context) operands))))
 
 (def boolean-ops
   "expression operands that result in a boolean result"
@@ -22,9 +42,9 @@
    :lt-eq <=
    :gt >
    :gt-eq >=
-   ;; NOTE: 'and' and 'or' are macros in Clojure, so we need to wrap them in functions here
-   :and #(and %1 %2)
-   :or #(or %1 %2)})
+   ;; NOTE: see comment above, these macros are wrapped as functions
+   :and and*
+   :or or*})
 
 (defn eval-expr [[expr-type & operands :as expr] context]
   (cond

test/json_path/test/json_path_test.clj

@@ -5,6 +5,19 @@
 
 (unfinished)
 
+(def keys-of-many-types
+  [{:key 1}
+   {:key 3}
+   {:key "nice"}
+   {:key true}
+   {:key nil}
+   {:key false}
+   {:key {}}
+   {:key []}
+   {:key -1}
+   {:key 0}
+   {:key ""}])
+
 (facts
   (at-path "$" ...json...) => ...json...
   (at-path "$.hello" {:hello "world"}) => "world"
@@ -28,25 +41,37 @@
                           {:id 45, :text "hello"}]}) => ["hello"]
   (at-path "$.foo[*].bar[*].baz"
            {:foo [{:bar [{:baz "hello"}]}]}) => ["hello"]
+  ;; Filter expression with boolean and operator
   (at-path "$[?(@.key>42 && @.key<44)]"
            [{:key 42}, {:key 43}, {:key 44}]) => [{:key 43}]
+  ;; Filter expression with boolean and operator and value false
+  (at-path "$[?(@.key>0 && false)]"
+           keys-of-many-types) => []
+  ;; Filter expression with boolean and operator and value true
+  (at-path "$[?(@.key>0 && true)]"
+           keys-of-many-types) => [{:key 1}, {:key 3}]
+  ;; Filter expression with boolean or operator
   (at-path "$[?(@.key>43 || @.key<43)]"
-           [{:key 42}, {:key 43}, {:key 44}]) => [{:key 42}, {:key 44}])
-
-  ;; TODO: add this case, comparator is blowing up comparing against different types
-  ;; "Filter expression with boolean or operator and value false"
-  ; (at-path "$[?(@.key>0 && false)]"
-  ;          [{:key 1}
-  ;           {:key 3}
-  ;           {:key "nice"}
-  ;           {:key true}
-  ;           {:key nil}
-  ;           {:key false}
-  ;           {:key {}}
-  ;           {:key []}
-  ;           {:key -1}
-  ;           {:key 0}
-  ;           {:key ""}]) => []
+           [{:key 42}, {:key 43}, {:key 44}]) => [{:key 42}, {:key 44}]
+  ;; Filter expression with boolean or operator and value false
+  (at-path "$[?(@.key>0 || false)]"
+           keys-of-many-types) => [{:key 1}, {:key 3}]
+  ;; Filter expression with boolean or operator and value true
+  (at-path "$[?(@.key>0 || true)]"
+           keys-of-many-types) => keys-of-many-types)
+  ;; TODO: Filter expression with different grouped operators
+  ;; NOTE: the parser will need to be updated in order to get this test to work
+  ; (at-path "$[?(@.a && (@.b || @.c))]"
+  ;          [{:a true}
+  ;           {:a true, :b true}
+  ;           {:a true, :b true, :c true}
+  ;           {:b true, :c true}
+  ;           {:a true, :c true}
+  ;           {:c true}
+  ;           {:b true}])
+  ; => [{:a true, :b true}
+  ;     {:a true, :b true, :c true}
+  ;     {:a true, :c true}])
 
 (facts
   (-> (query "$.hello"