Merge pull request #3892 from clojure-emacs/decouple-nrepl-handler

Decouple nrepl-make-eval-handler from CIDER's UI layer

Author: bbatsov

CHANGELOG.md

@@ -9,6 +9,7 @@
 - Introduce `cider-jack-in-tools` and `cider-register-jack-in-tool` so third-party packages can register new project tools for `cider-jack-in` and `cider-jack-in-universal`.
 - Cache the result of `cider--running-nrepl-paths` (used by `cider-locate-running-nrepl-ports`) for `cider-running-nrepl-paths-cache-ttl` seconds (default 5). Repeated `cider-connect` completions no longer re-spawn a fresh round of `ps`/`lsof` subprocesses each time. `cider-clear-running-nrepl-paths-cache` discards the cache on demand.
 - New `nrepl-make-eval-handler` with a keyword-arg API (`:on-value`, `:on-stdout`, `:on-stderr`, `:on-done`, `:on-eval-error`, `:on-content-type`, `:on-truncated`). Sub-handlers no longer take a buffer argument -- they close over whatever they need. `nrepl-make-response-handler`, the legacy 7-positional-arg form, is preserved as an obsolete shim that adapts the old (buffer x) lambdas to the new (x) lambdas, so existing extensions keep working.
+- Decouple the nREPL transport layer from CIDER's UI layer (closes [#1099](https://github.com/clojure-emacs/cider/issues/1099)). `nrepl-make-eval-handler` is now CIDER-agnostic: it no longer references `nrepl-namespace-handler-function`, `nrepl-err-handler-function`, `nrepl-need-input-handler-function`, or any hardcoded UI strings. New `:on-ns` and `:on-status` keyword slots let any consumer wire up their own namespace tracking and status handling. The editor-level `cider-make-eval-handler` wraps it with CIDER's UI behavior (ns tracking, default error handler, need-input prompt, "Evaluation interrupted." / "Namespace not found." messages); in-tree callers all use it.
 
 ### Bugs fixed
 

lisp/cider-client.el

@@ -40,6 +40,7 @@
 (require 'nrepl-client)
 
 (declare-function cider--render-stacktrace-causes "cider-eval")
+(declare-function cider-make-eval-handler "cider-eval")
 
 
 ;;; Spinner
@@ -493,7 +494,7 @@ itself is present."
 
 (defun cider-interrupt-handler (buffer)
   "Create an interrupt response handler for BUFFER."
-  (nrepl-make-eval-handler :buffer buffer))
+  (cider-make-eval-handler :buffer buffer))
 
 (defun cider-interrupt ()
   "Interrupt any pending evaluations."
@@ -905,7 +906,7 @@ FORMAT-OPTIONS is an optional configuration map for cljfmt."
   "Make a stdin response handler for _BUFFER.
 Intentionally swallows value/out/err so the response is consumed without
 side effects; only the global handlers fire (need-input, eval-error, ...)."
-  (nrepl-make-eval-handler :buffer (current-buffer)))
+  (cider-make-eval-handler :buffer (current-buffer)))
 
 (defun cider-need-input (buffer)
   "Handle an need-input request from BUFFER."

lisp/cider-eval.el

@@ -617,6 +617,49 @@ parsed location."
 
 
 ;;; Interactive evaluation handlers
+
+(declare-function cider--update-buffer-ns "cider-connection" (buffer ns))
+
+(cl-defun cider-make-eval-handler (&key buffer
+                                        on-value on-stdout on-stderr on-done
+                                        on-eval-error on-content-type on-truncated)
+  "Build an eval response handler with CIDER's UI behavior wired in.
+
+This is the editor-level wrapper around `nrepl-make-eval-handler': it
+forwards the standard slots (`:on-value', `:on-stdout', `:on-stderr',
+`:on-done', `:on-content-type', `:on-truncated', `:on-eval-error') and
+additionally:
+
+- updates BUFFER's `cider-buffer-ns' from the response's `ns' slot
+  (only for non-source buffers, via `cider--update-buffer-ns');
+- prompts the user via `cider-need-input' on \"need-input\" status;
+- prints \"Evaluation interrupted.\" on \"interrupted\" status;
+- prints \"Namespace `X' not found.\" on \"namespace-not-found\" status;
+- when no `:on-eval-error' is given, defaults to a thunk that calls
+  `cider-default-err-handler' with BUFFER.
+
+BUFFER is the editor buffer the response is associated with (typically
+the one that issued the eval).  All other slots have the same semantics
+as in `nrepl-make-eval-handler'."
+  (nrepl-make-eval-handler
+   :on-value on-value
+   :on-stdout on-stdout
+   :on-stderr on-stderr
+   :on-done on-done
+   :on-content-type on-content-type
+   :on-truncated on-truncated
+   :on-ns (lambda (ns) (cider--update-buffer-ns buffer ns))
+   :on-status (lambda (status response)
+                (when (member "interrupted" status)
+                  (message "Evaluation interrupted."))
+                (when (member "namespace-not-found" status)
+                  (nrepl-dbind-response response (ns)
+                    (message "Namespace `%s' not found." ns)))
+                (when (member "need-input" status)
+                  (cider-need-input buffer)))
+   :on-eval-error (or on-eval-error
+                      (lambda () (cider-default-err-handler buffer)))))
+
 (defun cider-insert-eval-handler (&optional buffer _bounds source-buffer on-success-callback)
   "Make an nREPL evaluation handler for the BUFFER,
 _BOUNDS representing the buffer bounds of the evaled input,
@@ -627,7 +670,7 @@ The handler simply inserts the result value in BUFFER."
   (let ((eval-buffer (current-buffer))
         (res "")
         (failed nil))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer (or buffer eval-buffer)
      :on-value (lambda (value)
                  (with-current-buffer buffer
@@ -727,7 +770,7 @@ when `cider-auto-inspect-after-eval' is non-nil."
          (end (when end (copy-marker end)))
          (fringed nil)
          (res ""))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer (or buffer eval-buffer)
      :on-value (lambda (value)
                  (setq res (concat res value))
@@ -763,7 +806,7 @@ Optional argument DONE-HANDLER lambda will be run once load is complete."
   (let* ((eval-buffer (current-buffer))
          (target (or buffer eval-buffer))
          (res ""))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer target
      :on-value (lambda (value)
                  (cider--display-interactive-eval-result value 'value)
@@ -788,7 +831,7 @@ Optional argument DONE-HANDLER lambda will be run once load is complete."
   ;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
   ;; See https://github.com/clojure-emacs/cider/pull/3162
   (let ((target (or buffer (current-buffer))))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer target
      :on-value (lambda (value)
                  (with-current-buffer target
@@ -803,7 +846,7 @@ Optional argument DONE-HANDLER lambda will be run once load is complete."
 LOCATION is the location marker at which to insert.  COMMENT-PREFIX is the
 comment prefix to use."
   (let ((res ""))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer buffer
      :on-value (lambda (value) (setq res (concat res value)))
      :on-stdout #'cider-emit-interactive-eval-output
@@ -842,7 +885,7 @@ COMMENT-PREFIX is the comment prefix for the first line of output.
 CONTINUED-PREFIX is the comment prefix to use for the remaining lines.
 COMMENT-POSTFIX is the text to output after the last line."
   (let ((res ""))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer buffer
      :on-value (lambda (value) (setq res (concat res value)))
      :on-stderr (lambda (err) (setq res (concat res err)))
@@ -870,7 +913,7 @@ This is used by pretty-printing commands."
   ;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
   ;; See https://github.com/clojure-emacs/cider/pull/3162
   (let ((chosen-buffer (or buffer (current-buffer))))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer chosen-buffer
      :on-value (lambda (value)
                  (cider-emit-into-popup-buffer chosen-buffer (ansi-color-apply value) nil t))

lisp/cider-profile.el

@@ -56,7 +56,7 @@
   "Make a response handler that calls HANDLER with the response value.
 HANDLER takes one argument (the value).  BUFFER, defaulting to the
 current buffer, is used by the global nREPL handlers (e.g. error)."
-  (nrepl-make-eval-handler
+  (cider-make-eval-handler
    :buffer (or buffer (current-buffer))
    :on-value handler))
 

lisp/cider-repl.el

@@ -52,6 +52,7 @@
 (require 'cider-resolve)
 
 (declare-function cider-inspect "cider-inspector")
+(declare-function cider-make-eval-handler "cider-eval")
 (declare-function cider-quit "cider-connection")
 (declare-function cider-restart "cider-connection")
 (declare-function cider-describe-connection "cider-connection")
@@ -272,7 +273,7 @@ This cache is stored in the connection buffer.")
   "Make an nREPL evaluation handler for use during REPL init.
 Run CALLBACK once the evaluation is complete."
   (let ((buffer (current-buffer)))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer buffer
      :on-stdout (apply-partially #'cider-repl-emit-stdout buffer)
      :on-stderr (apply-partially #'cider-repl-emit-stderr buffer)
@@ -1042,7 +1043,7 @@ and responding to them.")
 (defun cider-repl-handler (buffer)
   "Make an nREPL evaluation handler for the REPL BUFFER."
   (let ((show-prompt t))
-    (nrepl-make-eval-handler
+    (cider-make-eval-handler
      :buffer buffer
      :on-value (lambda (value)
                  (cider-repl-emit-result buffer value t))
@@ -1282,7 +1283,7 @@ With a prefix argument CLEAR-REPL it will clear the entire REPL buffer instead."
 
 (defun cider-repl-switch-ns-handler (buffer)
   "Make an nREPL evaluation handler for the REPL BUFFER's ns switching."
-  (nrepl-make-eval-handler
+  (cider-make-eval-handler
    :buffer buffer
    :on-stdout (apply-partially #'cider-repl-emit-stdout buffer)
    :on-stderr (apply-partially #'cider-repl-emit-stderr buffer)

lisp/nrepl-client.el

@@ -656,70 +656,63 @@ Displays the notification via `message'."
                 (format "%s: %s" (upcase type) msg))))
     (message msg)))
 
-(cl-defun nrepl-make-eval-handler (&key buffer
-                                        on-value on-stdout on-stderr on-done
+(cl-defun nrepl-make-eval-handler (&key on-value on-stdout on-stderr on-done
+                                        on-ns on-status
                                         on-eval-error on-content-type on-truncated)
   "Build a callback for an nREPL `eval'-style response stream.
 
 Returns a function of one argument (the decoded response dict).  The
-handler dispatches on the standard eval response slots and invokes
-whichever of the keyword sub-handlers has been provided:
+handler is a transport-layer building block: it dispatches on the
+standard eval response slots and invokes whichever of the keyword
+sub-handlers has been provided.  All UI concerns (namespace tracking,
+default error handling, need-input prompting, status messages) live in
+higher layers -- see `cider-make-eval-handler' for the editor wrapper.
+
+Sub-handlers, all optional:
 
   :on-value         called with VALUE when the response carries one.
   :on-stdout        called with the OUT string for stdout chunks.
   :on-stderr        called with the ERR string for stderr chunks.
   :on-done          called with no arguments on the final \"done\" status.
+  :on-ns            called with NS whenever the response carries an `ns'
+                    slot, regardless of which other slots are present.
+  :on-status        called with (STATUS RESPONSE) when the response
+                    carries a `status' slot.  STATUS is the list of
+                    status flags; RESPONSE is the full response dict
+                    so the handler can read sibling slots if needed.
   :on-eval-error    called with no arguments on \"eval-error\" status.
-                    If omitted, falls back to `nrepl-err-handler-function'
-                    (which is then invoked with BUFFER).
   :on-content-type  called with (BODY CONTENT-TYPE) when the response
                     carries a `content-type' slot.  BODY has been
                     base64-decoded when the response indicates so.
   :on-truncated     called with no arguments when the response is flagged
-                    as truncated by `nrepl.middleware.print'.
-
-Sub-handlers do not receive BUFFER -- close over whatever buffer or other
-context you need.  BUFFER is only passed to the global handlers
-configured via `nrepl-namespace-handler-function',
-`nrepl-err-handler-function', and `nrepl-need-input-handler-function'."
+                    as truncated by `nrepl.middleware.print'."
   (lambda (response)
     (nrepl-dbind-response response (content-type content-transfer-encoding body
                                                  value ns out err status id)
-      (when (and ns nrepl-namespace-handler-function)
-        (funcall nrepl-namespace-handler-function buffer ns))
+      (when (and ns on-ns)
+        (funcall on-ns ns))
       (cond ((and content-type on-content-type)
              (funcall on-content-type
                       (if (string= content-transfer-encoding "base64")
                           (base64-decode-string body)
                         body)
                       content-type))
             (value
-             (when on-value
-               (funcall on-value value)))
+             (when on-value (funcall on-value value)))
             (out
-             (when on-stdout
-               (funcall on-stdout out)))
+             (when on-stdout (funcall on-stdout out)))
             (err
-             (when on-stderr
-               (funcall on-stderr err)))
+             (when on-stderr (funcall on-stderr err)))
             (status
-             (when (and on-truncated (member "nrepl.middleware.print/truncated" status))
+             (when on-status (funcall on-status status response))
+             (when (and on-truncated
+                        (member "nrepl.middleware.print/truncated" status))
                (funcall on-truncated))
-             (when (member "interrupted" status)
-               (message "Evaluation interrupted."))
-             (when (member "eval-error" status)
-               (cond (on-eval-error (funcall on-eval-error))
-                     (nrepl-err-handler-function
-                      (funcall nrepl-err-handler-function buffer))))
-             (when (member "namespace-not-found" status)
-               (message "Namespace `%s' not found." ns))
-             (when (and (member "need-input" status)
-                        nrepl-need-input-handler-function)
-               (funcall nrepl-need-input-handler-function buffer))
+             (when (and on-eval-error (member "eval-error" status))
+               (funcall on-eval-error))
              (when (member "done" status)
                (nrepl--mark-id-completed id)
-               (when on-done
-                 (funcall on-done))))))))
+               (when on-done (funcall on-done))))))))
 
 (defun nrepl-make-response-handler (buffer value-handler stdout-handler
                                            stderr-handler done-handler
@@ -729,9 +722,18 @@ configured via `nrepl-namespace-handler-function',
   "Make a response handler for connection BUFFER.
 
 This is the legacy positional-arg form retained for backward
-compatibility with extensions.  It adapts the (BUFFER VALUE)-style
-sub-handlers expected here to the simpler (VALUE)-style sub-handlers of
-`nrepl-make-eval-handler', which is the form new code should use.
+compatibility with extensions.  New code should use
+`nrepl-make-eval-handler' (transport-only) or, in CIDER, the higher-
+level `cider-make-eval-handler' which layers UI concerns on top.
+
+The shim adapts the (BUFFER VALUE)-style sub-handlers expected here to
+the simpler (VALUE)-style sub-handlers of `nrepl-make-eval-handler',
+and additionally wires up the global handler hooks
+(`nrepl-namespace-handler-function', `nrepl-err-handler-function',
+`nrepl-need-input-handler-function') and the legacy status messages
+that used to live inside `nrepl-make-eval-handler' itself.  Anything
+that was visible behavior of the original 7-positional-arg API stays
+visible behavior here.
 
 VALUE-HANDLER, STDOUT-HANDLER, STDERR-HANDLER, DONE-HANDLER and
 EVAL-ERROR-HANDLER each receive BUFFER as their first argument; the
@@ -740,7 +742,6 @@ type; TRUNCATED-HANDLER receives BUFFER alone.  Any handler given as nil
 results in the corresponding response branch being a no-op."
   (declare (obsolete nrepl-make-eval-handler "1.22"))
   (nrepl-make-eval-handler
-   :buffer buffer
    :on-value (when value-handler
                (lambda (value) (funcall value-handler buffer value)))
    :on-stdout (when stdout-handler
@@ -749,8 +750,21 @@ results in the corresponding response branch being a no-op."
                 (lambda (err) (funcall stderr-handler buffer err)))
    :on-done (when done-handler
               (lambda () (funcall done-handler buffer)))
-   :on-eval-error (when eval-error-handler
-                    (lambda () (funcall eval-error-handler buffer)))
+   :on-ns (when nrepl-namespace-handler-function
+            (lambda (ns) (funcall nrepl-namespace-handler-function buffer ns)))
+   :on-status (lambda (status response)
+                (when (member "interrupted" status)
+                  (message "Evaluation interrupted."))
+                (when (member "namespace-not-found" status)
+                  (nrepl-dbind-response response (ns)
+                    (message "Namespace `%s' not found." ns)))
+                (when (and (member "need-input" status)
+                           nrepl-need-input-handler-function)
+                  (funcall nrepl-need-input-handler-function buffer)))
+   :on-eval-error (cond (eval-error-handler
+                         (lambda () (funcall eval-error-handler buffer)))
+                        (nrepl-err-handler-function
+                         (lambda () (funcall nrepl-err-handler-function buffer))))
    :on-content-type (when content-type-handler
                       (lambda (decoded type)
                         (funcall content-type-handler buffer decoded type)))