Support numbers in filter expressions

Author: cburgmer

src/json_path/parser.clj

@@ -34,6 +34,8 @@
   (let [next (first remaining)]
     (cond
      (empty? remaining) []
+     (re-matches #"\d+" next) [:val (Integer/parseInt next)]
+     (re-matches #"\d+\.\d*" next) [:val (Double/parseDouble next)]
      (= "\"" next) [:val (apply str (extract-sub-tree "\"" "\"" remaining))]
      (= "[" next) (do
                     (let [idx (parse-indexer (extract-sub-tree "[" "]" remaining))

test/Clojure_json-path.yaml

@@ -97,6 +97,34 @@ queries:
     result: "first"
     status: fail
     consensus: ["first", "second"]
+  - id: filter_greater_than
+    selector: $[?(@.key>42)]
+    document: [{"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}]
+    status: error
+    consensus: [{"key": 43}, {"key": 42.0001}, {"key": 100}]
+  - id: filter_greater_than_or_equal
+    selector: $[?(@.key>=42)]
+    document: [{"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"some": "value"}]
+    status: error
+    consensus: [{"key": 42}, {"key": 43}, {"key": 42.0001}, {"key": 100}]
+  - id: filter_less_than
+    selector: $[?(@.key<42)]
+    document: [{"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"some": "value"}]
+    status: error
+    consensus: [{"key": 0}, {"key": -1}, {"key": 41}, {"key": 41.9999}]
+  - id: filter_less_than_on_string
+    selector: $[?(@.key<42)]
+    document: [{"key": 0}, {"key": "value"}]
+    status: error
+  - id: filter_less_than_or_equal
+    selector: $[?(@.key<=42)]
+    document: [{"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"some": "value"}]
+    status: error
+  - id: filter_with_value
+    selector: $[?(@.key)]
+    document: [{"some": "some value"}, {"key": "value"}]
+    result: [{"key": "value"}]
+    status: pass
   - id: key_bracket_notation
     selector: $['key']
     document: {"key": "value"}

test/json_path/test/json_path_test.clj

@@ -18,6 +18,7 @@
   (at-path "$[*]" {:foo 1 :bar [2 3]}) => [1 [2 3]]
   (at-path "$..*" {:foo 1 :bar [2 3]}) => [1 [2 3] 2 3]
   (at-path "$[-2]" [1 2 3]) => 2
+  (at-path "$[?(@.bar<2)]" [{:bar 1} {:bar 2}]) => [{:bar 1}]
   (at-path "$.foo[?(@.bar=\"baz\")].hello"
            {:foo [{:bar "wrong" :hello "goodbye"}
                   {:bar "baz" :hello "world"}]}) => ["world"]

test/json_path/test/parser_test.clj

@@ -17,7 +17,9 @@
   (parse-expr '("\"" "bar" "\"" "<" "\"" "bar" "\"")) => [:lt [:val "bar"] [:val "bar"]]
   (parse-expr '("\"" "bar" "\"" "<=" "\"" "bar" "\"")) => [:lt-eq [:val "bar"] [:val "bar"]]
   (parse-expr '("\"" "bar" "\"" ">" "\"" "bar" "\"")) => [:gt [:val "bar"] [:val "bar"]]
-  (parse-expr '("\"" "bar" "\"" ">=" "\"" "bar" "\"")) => [:gt-eq [:val "bar"] [:val "bar"]])
+  (parse-expr '("\"" "bar" "\"" ">=" "\"" "bar" "\"")) => [:gt-eq [:val "bar"] [:val "bar"]]
+  (parse-expr '("\"" "bar" "\"" "=" "42")) => [:eq [:val "bar"] [:val 42]]
+  (parse-expr '("\"" "bar" "\"" "=" "3.1415")) => [:eq [:val "bar"] [:val 3.1415]])
 
 (fact
   (parse-indexer '("*")) => [:index "*"]
@@ -45,6 +47,12 @@
                                  [:selector [:filter [:some [:path [[:current]
                                                                     [:child]
                                                                     [:key "baz"]]]]]]]
+  (parse-path "$[?(@.bar<2)]") => [:path [[:root]]
+                                   [:selector [:filter [:lt
+                                                        [:path [[:current]
+                                                                [:child]
+                                                                [:key "bar"]]]
+                                                        [:val 2]]]]]
   (parse-path "$.foo[?(@.bar=\"baz\")].hello") => [:path [[:root] [:child] [:key "foo"]]
                                                    [:selector [:filter [:eq [:path [[:current]
                                                                                     [:child]

test/json_path/test/walker_test.clj

@@ -50,7 +50,9 @@
   (walk-selector [:filter [:eq [:path [[:current] [:child] [:key "bar"]]] [:val "baz"]]]
                  {:current (m/root [{:bar "wrong"} {:bar "baz"}])}) => (list (m/create {:bar "baz"} [1]))
   (walk-selector [:filter [:eq [:path [[:current] [:child] [:key "bar"]]] [:val "baz"]]]
-                 {:current (m/root {:one {:bar "wrong"} :other {:bar "baz"}})}) => (list (m/create {:bar "baz"} [:other])))
+                 {:current (m/root {:one {:bar "wrong"} :other {:bar "baz"}})}) => (list (m/create {:bar "baz"} [:other]))
+  (walk-selector [:filter [:gt [:path [[:current] [:child] [:key "bar"]]] [:val 42]]]
+                 {:current (m/root [{:bar 41} {:bar 43}])}) => (list (m/create {:bar 43} [1])))
 
 (fact "selecting places constraints on the shape of the object being selected from"
   (walk-selector [:index "1"] {:current (m/root {:foo "bar"})}) => (throws Exception))