Update to Solr 6.4.0

project.clj

@@ -1,11 +1,11 @@
-(defproject com.codesignals/flux "0.6.0"
+(defproject com.codesignals/flux "0.7.0"
   :description "A clojure client library for Solr"
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.7.0"]
-                 [org.apache.solr/solr-core "5.4.0"]
-                 [org.apache.solr/solr-solrj "5.4.0"]]
+                 [org.apache.solr/solr-core "6.4.0"]
+                 [org.apache.solr/solr-solrj "6.4.0"]]
   :profiles {:dev {:dependencies [[midje "1.6.3"]
                                   [org.slf4j/slf4j-log4j12 "1.7.7"]
                                   [commons-logging "1.1.3"]]

src/flux/client.clj

@@ -1,14 +1,14 @@
 (ns flux.client
-  (require [flux.update :refer [create-doc]]
-           [flux.query :refer [create-query]]
-           [flux.response :refer [->clojure]])
-  (import [org.apache.solr.client.solrj SolrServer]
-          [org.apache.solr.common SolrInputDocument]))
+  (:require [flux.update   :refer [create-doc]]
+            [flux.query    :refer [create-query]]
+            [flux.response :refer [->clojure]])
+  (:import (org.apache.solr.client.solrj SolrClient)
+           (org.apache.solr.common SolrInputDocument)))
 
-(defn query [^SolrServer solr-server query & [options]]
+(defn query [^SolrClient solr-server query & [options]]
   (->clojure (.query solr-server (create-query query options))))
 
-(defn request [^SolrServer solr-server request]
+(defn request [^SolrClient solr-server request]
   (->clojure (.request solr-server request)))
 
 (defmulti add
@@ -17,39 +17,39 @@
      (map? input) :one
      :else :default)))
 
-(defmethod add :one [^SolrServer client doc & {:as opts}]
+(defmethod add :one [^SolrClient client doc & {:as opts}]
   (->clojure (.add client (create-doc doc))))
 
-(defmethod add :default [^SolrServer client docs & {:as opts}]
+(defmethod add :default [^SolrClient client docs & {:as opts}]
   (->clojure (.add client ^java.util.Collection (map create-doc docs))))
 
-(defn commit [^SolrServer client & {:as opts}]
+(defn commit [^SolrClient client & {:as opts}]
   (->clojure (.commit client)))
 
 (letfn [(v [x]
           (cond (keyword? x) (name x) :else (str x)))]
-  (defn delete-by-id [^SolrServer client ids & {:as opts}]
+  (defn delete-by-id [^SolrClient client ids & {:as opts}]
     (->clojure
      (let [ids (if (coll? ids) (map v ids) (v ids))]
-      (.deleteById ^SolrServer client ^java.util.List ids)))))
+      (.deleteById ^SolrClient client ^java.util.List ids)))))
 
-(defn delete-by-query [^SolrServer client q & {:as opts}]
+(defn delete-by-query [^SolrClient client q & {:as opts}]
   (->clojure (.deleteByQuery client q)))
 
 (defn optimize
-  ([^SolrServer client]
+  ([^SolrClient client]
      (->clojure (.optimize client)))
-  ([^SolrServer client wait-flush wait-searcher]
+  ([^SolrClient client wait-flush wait-searcher]
      (->clojure (.optimize client wait-flush wait-searcher)))
-  ([^SolrServer client wait-flush wait-searcher max-segments]
+  ([^SolrClient client wait-flush wait-searcher max-segments]
      (->clojure
       (.optimize client wait-flush wait-searcher max-segments))))
 
-(defn rollback [^SolrServer client]
+(defn rollback [^SolrClient client]
   (->clojure (.rollback client)))
 
-(defn shutdown [^SolrServer client]
+(defn shutdown [^SolrClient client]
   (->clojure (.shutdown client)))
 
-(defn ping [^SolrServer client]
+(defn ping [^SolrClient client]
   (->clojure (.ping client)))

src/flux/cloud.clj

@@ -1,10 +1,10 @@
 (ns flux.cloud
-  (import [org.apache.solr.client.solrj.impl CloudSolrServer]))
+  :import (org.apache.solr.client.solrj.impl CloudSolrClient))
 
 (defn create
   ([zk-hosts]
-   (CloudSolrServer. zk-hosts))
+   (CloudSolrClient. zk-hosts))
   ([zk-hosts default-collection]
-   (let [server (CloudSolrServer. zk-hosts)]
+   (let [server (CloudSolrClient. zk-hosts)]
      (.setDefaultCollection server default-collection)
-     server)))
+     server)))

src/flux/core.clj

@@ -1,5 +1,5 @@
 (ns flux.core
-  (require [flux.client]))
+  (:require [flux.client]))
 
 (def ^:dynamic *connection*)
 

src/flux/embedded.clj

@@ -1,9 +1,9 @@
 (ns flux.embedded
-  (import [java.io File]
-          [org.apache.solr.client.solrj.embedded EmbeddedSolrServer]
-          [org.apache.solr.core CoreContainer]
-          [java.nio.file Paths]
-          [java.net URI]))
+  (:import (java.io File)
+           (org.apache.solr.client.solrj.embedded EmbeddedSolrServer)
+           (org.apache.solr.core CoreContainer)
+           (java.nio.file Paths)
+           (java.net URI)))
 
 (defn- str->path [str-path]
   (-> str-path File. .toURI Paths/get))

src/flux/http.clj

@@ -1,5 +1,5 @@
 (ns flux.http
-  (import [org.apache.solr.client.solrj.impl HttpSolrServer]))
+  (:import (org.apache.solr.client.solrj.impl HttpSolrClient)))
 
 (defn create [base-url core-name]
-  (HttpSolrServer. (str base-url "/" (name core-name))))
+  (HttpSolrClient. (str base-url "/" (name core-name))))

src/flux/query.clj

@@ -1,14 +1,18 @@
 (ns flux.query
-  (import [org.apache.solr.common.params MultiMapSolrParams]
-          [org.apache.solr.client.solrj.request QueryRequest]
-          [org.apache.solr.client.solrj SolrRequest$METHOD]))
+  (:import (org.apache.solr.common.params MultiMapSolrParams)
+           (org.apache.solr.client.solrj.request QueryRequest)
+           (org.apache.solr.client.solrj SolrRequest$METHOD)))
 
 (def method-map
   {:get SolrRequest$METHOD/GET
    :post SolrRequest$METHOD/POST})
 
 (defn- format-param [p]
-  (if (keyword? p) (name p) (str p)))
+  (cond
+    (keyword? p) (name p)
+    (map-entry? p) (let [[k v] p]
+                     (str (name k) ":" v))
+    :default (str p)))
 
 (defn- format-values [v]
   (into-array (mapv format-param (if (coll? v) v [v]))))

src/flux/response.clj

@@ -1,9 +1,11 @@
 (ns flux.response
-  (:import [org.apache.solr.client.solrj SolrResponse]
-           [org.apache.solr.common.util NamedList SimpleOrderedMap]
-           [org.apache.solr.common SolrDocumentList SolrDocument]
-           [org.apache.solr.common SolrInputDocument]
-           [java.util ArrayList]))
+  (:import (org.apache.solr.client.solrj SolrResponse)
+           (org.apache.solr.common.util NamedList
+                                        SimpleOrderedMap)
+           (org.apache.solr.common SolrDocumentList
+                                   SolrDocument)
+           (org.apache.solr.common SolrInputDocument)
+           (java.util ArrayList)))
 
 ;; TODO: Rename this ns to something like "conversion", not "response"
 

src/flux/update.clj

@@ -1,14 +1,12 @@
 (ns flux.update
-  (import [org.apache.solr.common SolrInputDocument]))
+  (:import (org.apache.solr.common SolrInputDocument
+                                   SolrInputField)))
 
 ;; NOTE: The result of this function is a SolrInputDocument
 ;; which throws an exception when printed!
 (defn create-doc ^SolrInputDocument [document-map]
   (reduce-kv (fn [^SolrInputDocument doc k v]
                (if (map? v)
-                 (let [m (doto (java.util.HashMap.)
-                           (.put (name (key (first v))) (val (first v))))]
-                   (doto doc (.addField (name k) m))
-                   doc)
+                 (doto doc (.addChildDocument (create-doc v)))
                  (doto doc (.addField (name k) v))))
-             (SolrInputDocument.) document-map))
+             (SolrInputDocument. (java.util.HashMap.)) document-map))

test/flux/unit/response.clj

@@ -1,7 +1,7 @@
 (ns flux.unit.response
-  (:require [flux.update :as update]
+  (:require [flux.update   :as update]
             [flux.response :refer :all]
-            [midje.sweet :refer :all]))
+            [midje.sweet   :refer :all]))
 
 (fact "create-map-from-document"
   (let [doc (update/create-doc {:id 1})]