Use nrepl.middleware.print

Author: cichli

README.md

@@ -268,8 +268,6 @@ Middleware        | Op(s)      | Description
 `wrap-macroexpand`| `macroexpand/macroexpand-1/macroexpand-all/macroexpand-step` | Macroexpand a Clojure form.
 `wrap-ns`         | `ns-list/ns-vars/ns-path/ns-load-all/ns-aliases` | Namespace browsing & loading.
 `wrap-spec`       | `spec-list/spec-form/spec-example` | Spec browsing.
-`wrap-pprint`     | - | **(DEPRECATED)** Adds pretty-printing support to code evaluation. It also installs a dummy `pprint-middleware` op. Thus `wrap-pprint` is discoverable through the `describe` op.
-`wrap-pprint-fn`  | - | **(DEPRECATED)** Provides a common pretty-printing interface for other middlewares that need to perform customisable pretty-printing.
 `wrap-profile`    | `toggle-profile/toggle-profile-ns/is-var-profiled/profile-summary/profile-var-summary/clear-profile/get-max-samples/set-max-samples` | Provides profiling support based on the [profile](https://github.com/thunknyc/profile) library.
 `wrap-refresh`    | `refresh/refresh-all/refresh-clear` | Code reloading.
 `wrap-resource`   | `resource` | Return resource path.

project.clj

@@ -95,7 +95,6 @@
                                                               cider.nrepl/wrap-macroexpand
                                                               cider.nrepl/wrap-ns
                                                               cider.nrepl/wrap-out
-                                                              cider.nrepl/wrap-pprint-fn
                                                               cider.nrepl/wrap-profile
                                                               cider.nrepl/wrap-refresh
                                                               cider.nrepl/wrap-resource

src/cider/nrepl.clj

@@ -2,12 +2,11 @@
   (:require
    [cider.nrepl.version :as version]
    [cider.nrepl.middleware.util.cljs :as cljs]
-   [cider.nrepl.middleware.pprint :as pprint]
    [cider.nrepl.print-method]
    [nrepl.middleware :refer [set-descriptor!]]
    [nrepl.middleware.caught :refer [wrap-caught]]
+   [nrepl.middleware.print :refer [wrap-print wrap-print-optional-arguments]]
    [nrepl.middleware.session :refer [session]]
-   [nrepl.middleware.pr-values :refer [pr-values]]
    [nrepl.server :as nrepl-server]))
 
 (def delayed-handlers
@@ -80,34 +79,10 @@
 ;; makes the code a bit more complex, but improves a lot the startup time
 ;; as almost nothing gets loaded during REPL boot time.
 
-(def wrap-pprint-fn-optional-arguments
-  "Common pprint arguments for CIDER's middleware."
-  {"pprint-fn" "The namespace-qualified name of a 1 or 2-arity function to use for pretty-printing. Defaults to `cider.nrepl.pprint/pprint`."
-   "print-options" "A map of configuration entries that the pprint-fn will understand. Those would typically be specific to the pprint-fn in question."})
-
-(def-wrapper wrap-pprint-fn cider.nrepl.middleware.pprint/handle-pprint-fn
-  (fn [msg] true)
-  {:doc "Middleware that provides a common interface for other middlewares that
-         need to perform customisable pretty-printing.
-
-         A namespace-qualified name of the function to be used for printing can
-         be optionally passed in the `:pprint-fn` slot, the default value being
-         `cider.nrepl.pprint/pprint`. The function name can be passed as
-         a string or symbol. Note that function should take 1 or two params - the
-         object to print and the an optional map of print params. The params should
-         be passed as `:print-options` - a map of key/value params.
-
-         The `:pprint-fn` slot will be replaced with the var that maps to the name
-         that was initially passed.
-
-         Middlewares further down the stack can then look up the `:pprint-fn`
-         slot, call it where necessary, and pass it the value of the `:print-options` slot."
-   :requires #{#'session}
-   :expects #{"eval" "load-file"}})
-
 (def-wrapper wrap-content-type cider.nrepl.middleware.content-type/handle-content-type
   #{"eval"}
   {:doc "Middleware that adds `content-type` annotations to the result of the the eval op."
+   :requires #{#'wrap-print}
    :expects #{"eval" "load-file"}
    :returns {"content-type" "A MIME type for the response, if one can be detected."
              "content-transfer-encoding" "The encoding (if any) of the content."
@@ -163,7 +138,7 @@
   (cljs/requires-piggieback
    {:doc "Provide instrumentation and debugging functionality."
     :expects  #{"eval"}
-    :requires #{#'wrap-pprint-fn #'session}
+    :requires #{#'wrap-print #'session}
     :handles {"debug-input"
               {:doc "Read client input on debug action."
                :requires {"input" "The user's reply to the input request."}
@@ -190,7 +165,7 @@
 
 (def-wrapper wrap-format cider.nrepl.middleware.format/handle-format
   {:doc "Middleware providing support for formatting Clojure code and EDN data."
-   :requires #{#'wrap-pprint-fn}
+   :requires #{#'wrap-print}
    :handles {"format-code"
              {:doc "Reformats the given Clojure code, returning the result as a string."
               :requires {"code" "The code to format."}
@@ -199,8 +174,7 @@
              "format-edn"
              {:doc "Reformats the given EDN data, returning the result as a string."
               :requires {"edn" "The data to format."}
-              :optional {"print-options" "A map of params for the print function."
-                         "pprint-fn" "Fully qualified name of the print function to be used."}
+              :optional wrap-print-optional-arguments
               :returns {"formatted-edn" "The formatted data."}}}})
 
 (def-wrapper wrap-info cider.nrepl.middleware.info/handle-info
@@ -229,7 +203,7 @@
            in the `:inspect` slot will cause the last value returned by eval to
            be inspected. Returns a string representation of the resulting
            inspector's state in the `:value` slot."
-    :requires #{"clone" #'pr-values #'wrap-caught}
+    :requires #{"clone" #'wrap-caught #'wrap-print}
     :expects #{"eval"}
     :handles {"inspect-pop"
               {:doc "Moves one level up in the inspector stack."
@@ -359,10 +333,10 @@
 
 (def-wrapper wrap-refresh cider.nrepl.middleware.refresh/handle-refresh
   {:doc "Refresh middleware."
-   :requires #{"clone" #'wrap-pprint-fn}
+   :requires #{"clone" #'wrap-print}
    :handles {"refresh"
              {:doc "Reloads all changed files in dependency order."
-              :optional (merge wrap-pprint-fn-optional-arguments
+              :optional (merge wrap-print-optional-arguments
                                {"dirs" "List of directories to scan. If no directories given, defaults to all directories on the classpath."
                                 "before" "The namespace-qualified name of a zero-arity function to call before reloading."
                                 "after" "The namespace-qualified name of a zero-arity function to call after reloading."})
@@ -372,7 +346,7 @@
                         "error-ns" "The namespace that caused reloading to fail when `status` is `:error`."}}
              "refresh-all"
              {:doc "Reloads all files in dependency order."
-              :optional (merge wrap-pprint-fn-optional-arguments
+              :optional (merge wrap-print-optional-arguments
                                {"dirs" "List of directories to scan. If no directories given, defaults to all directories on the classpath."
                                 "before" "The namespace-qualified name of a zero-arity function to call before reloading."
                                 "after" "The namespace-qualified name of a zero-arity function to call after reloading."})
@@ -415,31 +389,30 @@
   (cljs/requires-piggieback
    {:doc "Middleware that handles stacktrace requests, sending
            cause and stack frame info for the most recent exception."
-    :requires #{#'session #'wrap-pprint-fn}
+    :requires #{#'session #'wrap-print}
     :expects #{}
     :handles {"stacktrace" {:doc "Return messages describing each cause and stack frame of the most recent exception."
-                            :optional wrap-pprint-fn-optional-arguments
+                            :optional wrap-print-optional-arguments
                             :returns {"status" "\"done\", or \"no-error\" if `*e` is nil"}}}}))
 
 (def-wrapper wrap-test cider.nrepl.middleware.test/handle-test
   {:doc "Middleware that handles testing requests."
-   :requires #{#'session #'wrap-pprint-fn}
-   :expects #{#'pr-values}
+   :requires #{#'session #'wrap-print}
    :handles {"test-var-query"
              {:doc "Run tests specified by the `var-query` and return results. Results are cached for exception retrieval and to enable re-running of failed/erring tests."
-              :optional wrap-pprint-fn-optional-arguments}
+              :optional wrap-print-optional-arguments}
              "test"
              {:doc "[DEPRECATED] Run tests in the specified namespace and return results. This accepts a set of `tests` to be run; if nil, runs all tests. Results are cached for exception retrieval and to enable re-running of failed/erring tests."
-              :optional wrap-pprint-fn-optional-arguments}
+              :optional wrap-print-optional-arguments}
              "test-all"
              {:doc "[DEPRECATED] Run all tests in the project. If `load?` is truthy, all project namespaces are loaded; otherwise, only tests in presently loaded namespaces are run. Results are cached for exception retrieval and to enable re-running of failed/erring tests."
-              :optional wrap-pprint-fn-optional-arguments}
+              :optional wrap-print-optional-arguments}
              "test-stacktrace"
              {:doc "Rerun all tests that did not pass when last run. Results are cached for exception retrieval and to enable re-running of failed/erring tests."
-              :optional wrap-pprint-fn-optional-arguments}
+              :optional wrap-print-optional-arguments}
              "retest"
              {:doc "Return exception cause and stack frame info for an erring test via the `stacktrace` middleware. The error to be retrieved is referenced by namespace, var name, and assertion index within the var."
-              :optional wrap-pprint-fn-optional-arguments}}})
+              :optional wrap-print-optional-arguments}}})
 
 (def-wrapper wrap-trace cider.nrepl.middleware.trace/handle-trace
   {:doc     "Toggle tracing of a given var."
@@ -505,7 +478,6 @@
     wrap-out
     wrap-content-type
     wrap-slurp
-    wrap-pprint-fn
     wrap-profile
     wrap-refresh
     wrap-resource

src/cider/nrepl/middleware/debug.clj

@@ -8,6 +8,7 @@
    [cider.nrepl.middleware.util.instrument :as ins]
    [cider.nrepl.middleware.util.nrepl :refer [notify-client]]
    [nrepl.middleware.interruptible-eval :refer [*msg*]]
+   [nrepl.middleware.print :as print]
    [nrepl.middleware.session :as session]
    [nrepl.misc :refer [response-for]]
    [nrepl.transport :as transport]
@@ -216,7 +217,7 @@ this map (identified by a key), and will `dissoc` it afterwards."}
                     (when-not (instance? ThreadDeath root-ex#)
                       (debugger-send
                        {:status :eval-error
-                        :causes [(let [causes# (stacktrace/analyze-causes e# (:pprint-fn *msg*) (:print-options *msg*))]
+                        :causes [(let [causes# (stacktrace/analyze-causes e# (::print/print-fn *msg*))]
                                    (when (coll? causes#) (last causes#)))]})))
                   error#))]
      (if (= error# ~sym)
@@ -290,7 +291,7 @@ this map (identified by a key), and will `dissoc` it afterwards."}
     :causes [{:class "StackTrace"
               :message "Harmless user-requested stacktrace"
               :stacktrace (-> (Exception. "Dummy")
-                              (stacktrace/analyze-causes (:pprint-fn *msg*) (:print-options *msg*))
+                              (stacktrace/analyze-causes (::print/print-fn *msg*))
                               last :stacktrace)}]}))
 
 (def debug-commands

src/cider/nrepl/middleware/format.clj

@@ -7,7 +7,10 @@
    [clojure.string :as str]
    [clojure.tools.reader.edn :as edn]
    [clojure.tools.reader.reader-types :as readers]
-   [clojure.walk :as walk]))
+   [clojure.walk :as walk]
+   [nrepl.middleware.print :as print])
+  (:import
+   (java.io StringWriter)))
 
 ;;; Code formatting
 (defn- keyword->symbol [kw]
@@ -43,15 +46,18 @@
           (recur (conj forms form)))))))
 
 (defn- format-edn
-  [edn pprint-fn print-options]
+  [edn print-fn]
   (->> (read-edn edn)
-       (map #(pprint-fn % print-options))
+       (map (fn [value]
+              (let [writer (StringWriter.)]
+                (print-fn value writer)
+                (str writer))))
        (str/join "\n")
-       str/trim))
+       (str/trim)))
 
 (defn format-edn-reply
-  [{:keys [edn pprint-fn print-options] :as msg}]
-  {:formatted-edn (format-edn edn pprint-fn print-options)})
+  [{:keys [edn ::print/print-fn] :as msg}]
+  {:formatted-edn (format-edn edn print-fn)})
 
 ;;; Middleware op handling
 (defn handle-format [handler msg]

src/cider/nrepl/middleware/inspect.clj

@@ -16,18 +16,21 @@
       (alter-meta! update ::inspector #(apply f % args))
       (get ::inspector)))
 
+(defn- inspector-response
+  ([msg inspector]
+   (inspector-response msg inspector {:status :done}))
+  ([msg {:keys [rendered] :as inspector} resp]
+   (let [value (binding [*print-length* nil]
+                 (pr-str rendered))]
+     (response-for msg resp {:value value}))))
+
 (defn inspect-reply
   [{:keys [page-size transport] :as msg} eval-response]
   (let [value (cljs/response-value msg eval-response)
         page-size (or page-size 32)
         inspector (swap-inspector! msg #(-> (assoc % :page-size page-size)
                                             (inspect/start value)))]
-    (binding [*print-length* nil]
-      ;; Remove print-length limit because it breaks the output in the middle of
-      ;; the page when inspecting long sequences.
-      (transport/send
-       transport
-       (response-for msg :value (:rendered inspector))))))
+    (transport/send transport (inspector-response msg inspector {}))))
 
 (defn inspector-transport
   [{:keys [^Transport transport, session] :as msg}]
@@ -60,9 +63,6 @@
   [handler msg]
   (handler (eval-msg msg)))
 
-(defn- inspector-response [msg inspector]
-  (response-for msg :value (:rendered inspector) :status :done))
-
 (defn pop-reply [msg]
   (inspector-response msg (swap-inspector! msg inspect/up)))
 

src/cider/nrepl/middleware/pprint.clj

@@ -12,6 +12,7 @@
    [clojure.tools.namespace.reload :as reload]
    [clojure.tools.namespace.track :as track]
    [nrepl.middleware.interruptible-eval :refer [*msg*]]
+   [nrepl.middleware.print :as print]
    [nrepl.misc :refer [response-for]]
    [nrepl.transport :as transport]
    [orchard.misc :as u]))
@@ -74,8 +75,8 @@
               (format "%s is not a function of no arguments" sym))))
 
     (binding [*msg* msg
-              *out* (get @session #'*out*)
-              *err* (get @session #'*err*)]
+              *out* (print/replying-PrintWriter :out msg {})
+              *err* (print/replying-PrintWriter :err msg {})]
       (do
         (when (var? the-var)
           (@the-var))
@@ -90,16 +91,16 @@
 
 (defn- error-reply
   [{:keys [error error-ns]}
-   {:keys [pprint-fn print-options session transport] :as msg}]
+   {:keys [::print/print-fn session transport] :as msg}]
 
   (transport/send
    transport
    (response-for msg (cond-> {:status :error}
-                       error (assoc :error (analyze-causes error pprint-fn print-options))
+                       error (assoc :error (analyze-causes error print-fn))
                        error-ns (assoc :error-ns error-ns))))
 
   (binding [*msg* msg
-            *err* (get @session #'*err*)]
+            *err* (print/replying-PrintWriter :err msg {})]
     (repl-caught error)))
 
 (defn- result-reply