feat: transducer interface (#42)

* feat: tranducers interface
* feat: support for custom jackson object mappers
* feat: convenience transducer constructor
* feat: serializer and parser transducers
* feat: pretty-printer transducer
* fix: copy the object mapper
* refactor: transducer names as verbs
* refactor: -> value
* refactor: rename query->expression
* refactor: compare with :cat and without directly

Author: dainiusjocas

Diff for: deps.edn

@@ -9,11 +9,13 @@
                                                :exclusions  [org.slf4j/slf4j-log4j12
                                                              org.slf4j/slf4j-api
                                                              org.slf4j/slf4j-nop]}
-                 criterium/criterium          {:mvn/version "0.4.6"}}}
+                 criterium/criterium          {:mvn/version "0.4.6"}
+                 metosin/jsonista             {:mvn/version "0.3.7"}}}
   :test
   {:extra-paths ["test" "test/resources"]
    :extra-deps  {com.cognitect/test-runner {:git/url "https://github.com/cognitect-labs/test-runner.git"
-                                            :sha     "7284cda41fb9edc0f3bc6b6185cfb7138fc8a023"}}
+                                            :sha     "7284cda41fb9edc0f3bc6b6185cfb7138fc8a023"}
+                 metosin/jsonista          {:mvn/version "0.3.7"}}
    :main-opts   ["-m" "cognitect.test-runner"]}
   :clj-kondo
   {:main-opts  ["-m" "clj-kondo.main" "--lint" "src" "test"]

Diff for: src/jq/api/api_impl.clj

@@ -17,10 +17,19 @@
 
 (def jq-version Versions/JQ_1_6)
 
-(defn ->JsonNode ^JsonNode [data]
-  (if (instance? JsonNode data)
-    data
-    (.valueToTree mapper data)))
+(defn ->JsonNode
+  (^JsonNode [data] (->JsonNode mapper data))
+  (^JsonNode [^ObjectMapper mapper data]
+   (if (instance? JsonNode data)
+     data
+     (.valueToTree mapper data))))
+
+(defn JsonNode->clj
+  "Converts JsonNode to a Clojure value.
+  An optional object mapper can be passed to handle data types such as keywords."
+  ([^JsonNode json-node] (JsonNode->clj mapper json-node))
+  ([^ObjectMapper mapper ^JsonNode json-node]
+   (.treeToValue mapper json-node ^Class Object)))
 
 (defn ->absolute-path
   "FileSystemModuleLoader requires absolute paths."
@@ -64,11 +73,15 @@
       scope)
     old-scope))
 
-(defn string->json-node ^JsonNode [^String data]
-  (.readTree mapper data))
+(defn string->json-node
+  (^JsonNode [^String data] (string->json-node mapper data))
+  (^JsonNode [^ObjectMapper mapper ^String data]
+   (.readTree mapper data)))
 
-(defn json-node->string ^String [^JsonNode data]
-  (.writeValueAsString mapper data))
+(defn json-node->string
+  (^String [^JsonNode data] (json-node->string mapper data))
+  (^String [^ObjectMapper mapper ^JsonNode data]
+   (.writeValueAsString mapper data)))
 
 ; Helper interface that specifies a method to get a string value.
 (definterface IContainer

Diff for: src/jq/transducers.clj

@@ -0,0 +1,81 @@
+(ns jq.transducers
+  (:require [jq.api :as api]
+            [jq.api.api-impl :as impl])
+  (:import (com.fasterxml.jackson.databind ObjectMapper SerializationFeature)))
+
+(defn ->JsonNode
+  "Returns a transducer that given a Java object maps it to a JsonNode.
+  Accepts an optional Jackson ObjectMapper."
+  ([] (map impl/->JsonNode))
+  ([^ObjectMapper mapper]
+   (map (partial impl/->JsonNode mapper))))
+
+(defn JsonNode->value
+  "Returns a transducer that give a JsonNode maps it to a Java Object.
+  Accepts an optional Jackson ObjectMapper."
+  ([] (map impl/JsonNode->clj))
+  ([^ObjectMapper mapper]
+   (map (partial impl/JsonNode->clj mapper))))
+
+(defn parse
+  "Returns a transducer that given a JSON String parses it into a JsonNode.
+  Accepts an optional Jackson ObjectMapper."
+  ([] (map impl/string->json-node))
+  ([^ObjectMapper mapper]
+   (map (partial impl/string->json-node mapper))))
+
+(defn serialize
+  "Returns a transducer that given a JsonNode serializes it to a String.
+  Accepts an optional Jackson ObjectMapper."
+  ([] (map impl/json-node->string))
+  ([^ObjectMapper mapper]
+   (map (partial impl/json-node->string mapper))))
+
+;; Pretty printer serializer
+(defn pretty-print
+  "Same as the `serializer` but the output string is indented.
+  ObjectMapper is copied to prevent side effects in case mapper is shared."
+  ([] (pretty-print impl/mapper))
+  ([^ObjectMapper mapper]
+   (map (partial impl/json-node->string
+                 (.enable (.copy mapper) SerializationFeature/INDENT_OUTPUT)))))
+
+(defn execute
+  "Returns a transducer that accepts JsonNode on which
+  the expression will be applied.
+  Optional opts are supported that are passed for the `jq.api/stream-processor`.
+  Specific opts for the transducer:
+    :cat - whether to catenate output, default true"
+  ([^String expression] (execute expression {}))
+  ([^String expression opts]
+   (let [xf (map (api/stream-processor expression opts))]
+     (if (false? (:cat opts))
+       xf
+       (comp xf cat)))))
+
+(defn process
+  "Returns a convenience transducer that:
+  - maps a Java Object to a JsonNode;
+  - maps a JQ expression on the JsonNode;
+  - catenates the output;
+  - maps a JsonNode to a JavaObject.
+  Accept opts that will be passed to the `jq.api/stream-processor`
+  Accepts a Jackson ObjectMapper that will be used for both"
+  ([^String expression] (process expression {}))
+  ([^String expression opts] (process expression opts impl/mapper))
+  ([^String expression opts ^ObjectMapper mapper]
+   (comp
+     (->JsonNode mapper)
+     (execute expression (assoc opts :cat true))
+     (JsonNode->value mapper))))
+
+(comment
+  ; Duplicates input
+  (into []
+        (comp
+          (->JsonNode)
+          (execute "(. , .)")
+          (JsonNode->value))
+        [1 2 3])
+
+  (into [] (process "(. , .)") [1 2 3]))

Diff for: test/jq/transducers_test.clj

@@ -0,0 +1,106 @@
+(ns jq.transducers-test
+  (:require [clojure.test :refer [deftest is testing]]
+            [jq.transducers :as jq]
+            [jsonista.core :as json]))
+
+(deftest transducers-interface
+  (let [data [1 2 3]
+        expression ".+1"
+        expected-result [2 3 4]]
+    (testing "mapper"
+      (is (= expected-result
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute expression)
+                         (jq/JsonNode->value))
+                       data))))
+
+    (testing "string input is not parsed, it is converted to TextNode as is"
+      (is (= ["test"]
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute ".")
+                         (jq/JsonNode->value))
+                       ["test"]))))
+
+    (testing "JSON string parser, it is converted to TextNode as is"
+      (is (= [{"foo" "bar"}]
+             (sequence (comp
+                         (jq/parse)
+                         (jq/execute ".")
+                         (jq/JsonNode->value))
+                       [(json/write-value-as-string {"foo" "bar"})]))))
+
+    (testing "string serializer"
+      (is (= ["{\"a\":\"b\"}" "{\"a\":\"b\"}"]
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute "(. , .)")
+                         (jq/serialize))
+                       [{"a" "b"}]))))
+
+    (testing "output catenation opt"
+      (is (= (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute expression)
+                         (jq/JsonNode->value))
+                       data)
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute expression {:cat false})
+                         cat
+                         (jq/JsonNode->value))
+                       data))))
+
+    (testing "multiple scripts in a row"
+      (is (= [3 4 5]
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute expression)
+                         (jq/execute expression)
+                         (jq/JsonNode->value))
+                       data))))))
+
+(deftest custom-mappers
+  (let [data [{:a :b}]
+        expression "."]
+    (testing "default object mapper is bad at keywords"
+      (is (= [{":a" {"name"      "b"
+                     "namespace" nil
+                     "sym"       {"name"      "b"
+                                  "namespace" nil}}}]
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute expression)
+                         (jq/JsonNode->value))
+                       data))))
+    (testing "keyword aware mappers"
+      (let [mapper json/keyword-keys-object-mapper]
+        (is (= [{:a "b"}]
+               (sequence (comp
+                           (jq/->JsonNode mapper)
+                           (jq/execute expression)
+                           (jq/JsonNode->value mapper))
+                         data)))))
+
+    (testing "parser and serializer"
+      (is (= ["{\"foo\":\"bar\"}" "{\"foo\":\"bar\"}"]
+             (sequence (comp
+                         (jq/parse json/keyword-keys-object-mapper)
+                         (jq/execute "(. , .)")
+                         (jq/serialize json/keyword-keys-object-mapper))
+                       [(json/write-value-as-string {:foo "bar"})]))))
+
+    (testing "pretty serializer"
+      (is (= ["{\n  \"foo\" : \"bar\"\n}"]
+             (sequence (comp
+                         (jq/->JsonNode)
+                         (jq/execute ".")
+                         (jq/pretty-print))
+                       [{"foo" "bar"}]))))))
+
+(deftest convenience-transducer
+  (let [data [1 2 3]
+        expression "(. , .)"]
+    (is (= [1 1 2 2 3 3]
+           (sequence (jq/process expression) data)))))