Make cider-current-connection retrieve the most recently used connection

Author: vspinu

CHANGELOG.md

@@ -28,6 +28,7 @@
 * Make it possible to disable auto-evaluation of changed ns forms via the defcustom `cider-auto-track-ns-form-changes`.
 * [#1991](https://github.com/clojure-emacs/cider/issues/1832): Make it possible to disable the prompt to open a ClojureScript in a browser on connect via `cider-offer-to-open-cljs-app-in-browser`.
 * [#1995](https://github.com/clojure-emacs/cider/pull/1995): Add new customization variable `cider-doc-auto-select-buffer` to control cider-doc popup buffer auto selection.
+* Ensure that `cider-current-connection` picks the most recently used connection in ambiguous cases.
 * Ensure that `cider-switch-to-repl-buffer` picks the most recent repl buffer if multiple connections are available.
 * Add new function `cider-project-connections-types`.
 

cider-client.el

@@ -253,6 +253,9 @@ evaluation commands to use a particular connection."
 A REPL is relevant if its `nrepl-project-dir' is compatible with the
 current directory (see `cider-find-connection-buffer-for-project-directory').
 
+When there are multiple relevant connections of the same TYPE, return the
+most recently used one.
+
 If TYPE is provided, it is either \"clj\" or \"cljs\", and only a
 connection of that type is returned.  If no connections of that TYPE exist,
 return nil.
@@ -263,32 +266,38 @@ returned.  In this case, only return nil if there are no active connections
 at all."
   ;; If TYPE was specified, we only return that type (or nil).  OW, we prefer
   ;; that TYPE, but ultimately allow any type.
-  (cl-labels ((right-type-p
-               (c)
-               (when (or (not type)
-                         (and (buffer-live-p c)
-                              (with-current-buffer c (equal cider-repl-type type))))
-                 c)))
+  (cl-labels ((right-type-p (c type)
+                            (when (or (not type)
+                                      (and (buffer-live-p c)
+                                           (equal (cider--connection-type c) type)))
+                              c))
+              (most-recent-buf (connections type)
+                               (when connections
+                                 (seq-find (lambda (c)
+                                             (and (member c connections)
+                                                  (right-type-p c type)))
+                                           (buffer-list)))))
     (let ((connections (cider-connections)))
       (cond
        ((not connections) nil)
        ;; if you're in a REPL buffer, it's the connection buffer
-       ((and (derived-mode-p 'cider-repl-mode) (right-type-p (current-buffer))))
+       ((and (derived-mode-p 'cider-repl-mode) (right-type-p (current-buffer) type)))
        ((eq cider-request-dispatch 'static) (car connections))
-       ((= 1 (length connections)) (right-type-p (car connections)))
+       ((= 1 (length connections)) (right-type-p (car connections) type))
        (t (let ((project-connections (cider-find-connection-buffer-for-project-directory
                                       nil :all-connections))
                 (guessed-type (or type (cider-connection-type-for-buffer))))
-            ;; So we have multiple connections. Look for the connection type we
-            ;; want, prioritizing the current project.
-            (or (seq-find (lambda (conn)
-                            (equal (cider--connection-type conn) guessed-type))
-                          project-connections)
-                (seq-find (lambda (conn)
-                            (equal (cider--connection-type conn) guessed-type))
-                          connections)
-                (right-type-p (car project-connections))
-                (right-type-p (car connections)))))))))
+            (or
+             ;; cljc
+             (and (equal guessed-type "multi")
+                  (most-recent-buf project-connections nil))
+             ;; clj or cljs
+             (and guessed-type
+                  (or (most-recent-buf project-connections guessed-type)
+                      (most-recent-buf connections guessed-type)))
+             ;; when type was not specified or guessed
+             (most-recent-buf project-connections type)
+             (most-recent-buf connections type))))))))
 
 (defun cider-other-connection (&optional connection)
   "Return the first connection of another type than CONNECTION.

test/cider-client-tests.el

@@ -88,6 +88,29 @@ SYMBOL is locally let-bound to the current buffer."
                 (setq major-mode 'clojurescript-mode)
                 (expect (cider-current-connection) :to-equal b2)))))))
 
+    (it "always returns the most recently used connection"
+      (with-connection-buffer "clj" bb1
+        (with-connection-buffer "cljs" bb2
+          (with-connection-buffer "clj" b1
+            (with-connection-buffer "cljs" b2
+
+              (switch-to-buffer bb2)
+              (switch-to-buffer bb1)
+              (expect (cider-current-connection) :to-equal bb1)
+
+              ;; follows type arguments
+              (expect (cider-current-connection "clj") :to-equal bb1)
+              (expect (cider-current-connection "cljs") :to-equal bb2)
+
+              ;; follows file type
+              (with-temp-buffer
+                (setq major-mode 'clojure-mode)
+                (expect (cider-current-connection) :to-equal bb1))
+
+              (with-temp-buffer
+                (setq major-mode 'clojurescript-mode)
+                (expect (cider-current-connection) :to-equal bb2)))))))
+
     (describe "when type argument is given"
       (describe "when connection of that type exists"
         (it "returns that connection buffer"
@@ -288,13 +311,15 @@ SYMBOL is locally let-bound to the current buffer."
       (with-temp-buffer
         (setq-local nrepl-endpoint '("localhost" 4005))
         (setq-local nrepl-project-dir "proj")
+        (setq-local cider-repl-type "clj")
         (expect (cider--connection-info (current-buffer))
                 :to-equal "CLJ proj@localhost:4005 (Java 1.7, Clojure 1.7.0, nREPL 0.2.1)"))))
 
   (describe "when current project is not known"
     (it "returns information about the connection buffer without project name"
       (with-temp-buffer
         (setq-local nrepl-endpoint '("localhost" 4005))
+        (setq-local cider-repl-type "clj")
         (expect (cider--connection-info (current-buffer))
                 :to-equal "CLJ <no project>@localhost:4005 (Java 1.7, Clojure 1.7.0, nREPL 0.2.1)")))))
 
@@ -333,9 +358,9 @@ SYMBOL is locally let-bound to the current buffer."
     (setq cider-repl-type "cljs")
     (expect (cider-connection-type-for-buffer) :to-equal "cljs"))
 
-  (it "returns clj as its default value"
+  (it "returns nil as its default value"
     (setq cider-repl-type nil)
-    (expect (cider-connection-type-for-buffer) :to-equal "clj")))
+    (expect (cider-connection-type-for-buffer) :to-equal nil)))
 
 
 (describe "cider-nrepl-send-unhandled-request"
@@ -372,12 +397,16 @@ SYMBOL is locally let-bound to the current buffer."
 
 
 (describe "cider-extract-designation-from-current-repl-buffer"
+
   (describe "when the buffers have a designation"
     (it "returns that designation string"
       (with-temp-buffer
-        (let* ((cider-connections (list (current-buffer))))
+        (let ((cider-connections (list (current-buffer)))
+              (nrepl-repl-buffer-name-template "*cider-repl%s*"))
           (rename-buffer "*cider-repl bob*")
+          (switch-to-buffer (current-buffer))
           (with-temp-buffer
+            (switch-to-buffer (current-buffer))
             (expect (cider-extract-designation-from-current-repl-buffer)
                     :to-equal "bob")
             (rename-buffer "*cider-repl apa*")
@@ -402,6 +431,7 @@ SYMBOL is locally let-bound to the current buffer."
                 (expect (cider-extract-designation-from-current-repl-buffer)
                         :to-equal "<no designation>")))))))))
 
+
 (describe "cider-project-name"
   (it "returns the project name extracted from the project dir"
     (expect (cider-project-name nil) :to-equal "-")