Merge remote-tracking branch 'origin/main' into issue-37

Author: charles-dyfis-net

Diff for: cli/jq/cli.clj

@@ -24,13 +24,13 @@
   (println summary))
 
 (defn execute [jq-filter files _]
-  (let [jq-processor (jq/flexible-processor jq-filter {:multi true, :output :json-node})]
+  (let [jq-processor (jq/flexible-processor jq-filter {:output :json-node})]
     (if (seq files)
       (doseq [f files
               item (jq-processor (slurp f))]
         (println (jq/json-node->string item)))
       (when (.ready ^Reader *in*)
-        (doseq [line (line-seq (BufferedReader. *in*))
+        (doseq [^String line (line-seq (BufferedReader. *in*))
                 item (jq-processor line)]
           (println (jq/json-node->string item)))))))
 

Diff for: src/jq/api.clj

@@ -7,38 +7,35 @@
 ; required in common use cases, so moving out of impl space
 (def json-node->string impl/json-node->string)
 
-(defn- container [opts]
-  (when (:multi opts) (impl/NewMultiOutputContainer)))
-
 ; jq docs http://manpages.ubuntu.com/manpages/hirsute/man1/jq.1.html
 (defn execute
   "Given a JSON data string (1) and a JQ query string (2)
   returns a JSON string result of (2) applied on (1).
+  Output stream is joined with the new-line symbol.
   Accepts optional options map.
-  NOTE: if your query doesn't change the use the `processor`."
+  NOTE: if your query doesn't change then use the `processor`."
   (^String [^String data ^String query]
    (execute data query {}))
   (^String [^String data ^String query opts]
    (impl/apply-json-query-on-string-data
      data
      (impl/compile-query query)
-     (impl/new-scope opts)
-     (container opts))))
+     (impl/new-scope opts))))
 
 (defn processor
   "Given a JQ query string (1) compiles it and returns a function that given
   a JSON string (2) will return a JSON string with (1) applied on (2).
+  Output stream is joined with the new-line symbol.
   Accepts optional options map."
   ([^String query] (processor query {}))
   ([^String query opts]
    (let [^JsonQuery json-query (impl/compile-query query)
          ^Scope scope (impl/new-scope opts)]
      (fn this
        (^String [^String data]
-        (this data nil))
+         (this data nil))
        (^String [^String data {:keys [vars]}]
-        (impl/apply-json-query-on-string-data
-          data json-query (impl/scope-with-vars scope vars) (container opts)))))))
+         (impl/apply-json-query-on-string-data data json-query (impl/scope-with-vars scope vars)))))))
 
 (defn flexible-processor
   "Given a JQ query string (1) compiles it and returns a function that given
@@ -49,8 +46,7 @@
   ([^String query opts]
    (let [^JsonQuery query (impl/compile-query query)
          output-format (get opts :output :string)
-         ^Scope scope (impl/new-scope opts)
-         container (container opts)]
+         ^Scope scope (impl/new-scope opts)]
      (fn this
        ([json-data]
         (this json-data nil))
@@ -59,19 +55,19 @@
           (cond
             ; string => string
             (and (string? json-data) (= :string output-format))
-            (impl/apply-json-query-on-string-data json-data query call-scope container)
+            (impl/apply-json-query-on-string-data json-data query call-scope)
 
             ; string => json-node
             (and (string? json-data) (not= :string output-format))
-            (impl/apply-json-query-on-json-node (impl/string->json-node json-data) query call-scope container)
+            (impl/apply-json-query-on-json-node (impl/string->json-node json-data) query call-scope)
 
             ; json-node => string
             (and (not (string? json-data)) (= :string output-format))
-            (impl/apply-json-query-on-json-node-data json-data query call-scope container)
+            (impl/apply-json-query-on-json-node-data json-data query call-scope)
 
             ; json-node => json-node
             (and (not (string? json-data)) (not= :string output-format))
-            (impl/apply-json-query-on-json-node json-data query call-scope container))))))))
+            (impl/apply-json-query-on-json-node json-data query call-scope))))))))
 
 (comment
   (jq.api/execute "{\"a\":[1,2,3,4,5],\"b\":\"hello\"}" ".")

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

@@ -1,10 +1,11 @@
 (ns ^{:doc    "Internal implementation details."
       :no-doc true}
   jq.api.api-impl
+  (:require [clojure.string :as str])
   (:import (java.util ArrayList)
            (net.thisptr.jackson.jq JsonQuery Versions Scope BuiltinFunctionLoader Output)
            (com.fasterxml.jackson.databind ObjectMapper JsonNode)
-           (com.fasterxml.jackson.databind.node JsonNodeFactory)
+           (com.fasterxml.jackson.databind.node ArrayNode JsonNodeFactory)
            (net.thisptr.jackson.jq.module.loaders ChainedModuleLoader BuiltinModuleLoader FileSystemModuleLoader)
            (net.thisptr.jackson.jq.module ModuleLoader)
            (java.nio.file Path)
@@ -63,60 +64,56 @@
       scope)
     old-scope))
 
+(defn string->json-node ^JsonNode [^String data]
+  (.readTree mapper data))
+
+(defn json-node->string ^String [^JsonNode data]
+  (.writeValueAsString mapper data))
+
 ; Helper interface that specifies a method to get a string value.
 (definterface IContainer
   ; net.thisptr.jackson.jq/Output
-  (^com.fasterxml.jackson.databind.JsonNode getValue []))
+  (^java.lang.Iterable getValue []))
 
 ; Container class helper that implements the net.thisptr.jackson.jq.Output
 ; interface that enables the class to be used as a callback for JQ and exposes the
 ; unsynchronized-mutable container field for the result of the JQ transformation.
-(deftype SingleOutputContainer [^:unsynchronized-mutable ^JsonNode container]
+(deftype JsonNodeOutputContainer [^ArrayNode container]
   Output
-  (emit [_ json-node] (set! container json-node))
+  (emit [_ json-node] (.add container json-node))
   IContainer
   (getValue [_] container))
 
-(deftype MultiOutputContainer [^ArrayList container]
+(defn json-node-output-container []
+  (JsonNodeOutputContainer. (.arrayNode JsonNodeFactory/instance)))
+
+(deftype StringOutputContainer [^ArrayList container]
   Output
-  (emit [_ json-node]
-    (.add container json-node))
+  (emit [_ json-node] (.add container (json-node->string json-node)))
   IContainer
-  (getValue [_]
-    (let [jsonArray (.arrayNode JsonNodeFactory/instance (.size container))]
-      (doseq [^JsonNode item container]
-        (.add jsonArray item))
-      (.clear container)
-      jsonArray)))
+  (getValue [_] container))
 
-(defn NewMultiOutputContainer []
-  (MultiOutputContainer. (ArrayList.)))
+(defn string-output-container []
+  (StringOutputContainer. (ArrayList.)))
 
 (defn apply-json-query-on-json-node
   "Given a JSON data string and a JsonQuery object applies the query
   on the JSON data string and return JsonNode; may be given a custom IContainer"
-  (^JsonNode [^JsonNode json-node ^JsonQuery json-query ^Scope scope ^IContainer output-container]
-    (let [^IContainer output-container (or output-container (SingleOutputContainer. nil))]
-      (.apply json-query (Scope/newChildScope scope) json-node output-container)
-      (.getValue output-container)))
-  (^JsonNode [^JsonNode json-node ^JsonQuery json-query ^Scope scope]
-    (apply-json-query-on-json-node json-node json-query scope nil)))
+  ([^JsonNode json-node ^JsonQuery json-query ^Scope scope ^IContainer container]
+   (.apply json-query (Scope/newChildScope scope) json-node container)
+   (.getValue container))
+  ([^JsonNode json-node ^JsonQuery json-query ^Scope scope]
+   (apply-json-query-on-json-node json-node json-query scope (json-node-output-container))))
 
-(defn string->json-node ^JsonNode [^String data]
-  (.readTree mapper data))
-
-(defn json-node->string ^String [^JsonNode data]
-  (.writeValueAsString mapper data))
+(defn apply-json-query-on-json-node-data
+  "Passes a JsonNode to the query executor."
+  ^String [^JsonNode data ^JsonQuery query ^Scope scope]
+  (str/join "\n" (apply-json-query-on-json-node data query scope (string-output-container))))
 
 (defn apply-json-query-on-string-data
   "Reads data JSON string into a JsonNode and passes to the query executor."
-  ^String [^String data ^JsonQuery query ^Scope scope ^IContainer output-container]
-  (json-node->string (apply-json-query-on-json-node (string->json-node data) query scope output-container)))
-
-(defn apply-json-query-on-json-node-data
-  "Reads data JSON string into a JsonNode and passes to the query executor."
-  ^String [^JsonNode data ^JsonQuery query ^Scope scope ^IContainer output-container]
-  (json-node->string (apply-json-query-on-json-node data query scope output-container)))
+  ^String [^String data ^JsonQuery query ^Scope scope]
+  (apply-json-query-on-json-node-data (string->json-node data) query scope))
 
 (defn new-scope
   (^Scope [] (Scope/newChildScope root-scope))

Diff for: test/jq/api_test.clj

@@ -62,16 +62,14 @@
     (let [data-1 "[1,2,3]"
           data-2 "[4,5,6]" ;; testing two calls ensures we aren't retaining extra state
           script ".[] | {\"out\": .}"
-          processor-fn (jq/flexible-processor script {:output :string
-                                                      :multi true})]
-      (is (= "[{\"out\":1},{\"out\":2},{\"out\":3}]" (processor-fn data-1)))
-      (is (= "[{\"out\":4},{\"out\":5},{\"out\":6}]" (processor-fn data-2)))))
+          processor-fn (jq/flexible-processor script {:output :string})]
+      (is (= "{\"out\":1}\n{\"out\":2}\n{\"out\":3}" (processor-fn data-1)))
+      (is (= "{\"out\":4}\n{\"out\":5}\n{\"out\":6}" (processor-fn data-2)))))
   (testing "checking that queries can choose not to return any output given an input"
     (let [data "[9,10,11]"
           script ".[] | select(. >= 10)"
-          processor-fn (jq/flexible-processor script {:output :string
-                                                      :multi true})]
-      (is (= "[10,11]" (processor-fn data))))))
+          processor-fn (jq/flexible-processor script {:output :string})]
+      (is (= "10\n11" (processor-fn data))))))
 
 (deftest string-to-string-execution
   (testing "mapping function onto values"
@@ -89,13 +87,15 @@
       (is (= result-string (processor-fn string-data)))))
 
   (testing "String to JsonNode"
-    (let [processor-fn (jq/flexible-processor query {:output :json-node})
+    (let [result-string "[[2,3,4]]"
+          processor-fn (jq/flexible-processor query {:output :json-node})
           resp (processor-fn string-data)]
       (is (instance? JsonNode resp))
       (is (= result-string (utils/json-node->string resp)))))
 
   (testing "JsonNode to JsonNode"
-    (let [processor-fn (jq/flexible-processor query {:output :json-node})
+    (let [result-string "[[2,3,4]]"
+          processor-fn (jq/flexible-processor query {:output :json-node})
           resp (processor-fn json-node-data)]
       (is (instance? JsonNode resp))
       (is (= result-string (utils/json-node->string resp)))))