Drop clojure-expected-ns' delegation from cider-expected-ns'

Inline the path-based namespace derivation that was previously
delegated to `clojure-expected-ns'.  The new internal helper
`cider--ns-from-path' uses `cider-project-dir' to find the project
root, then applies the same drop-first-dir + path-to-ns +
strip-known-prefixes algorithm clojure-mode uses (with prefixes now
owned by cider via `cider-directory-prefixes').

Behavior is unchanged for files on the classpath (still preferred)
and for files in a recognized project layout.  Tests rewritten to
assert the new behavior directly instead of the old "delegates to
clojure-expected-ns" coupling.

Author: bbatsov

CHANGELOG.md

@@ -34,6 +34,7 @@
 ### Changes
 
 - Project root detection no longer goes through `clojure-mode'/`clojure-ts-mode'.  New `cider-project-dir' built on top of `project.el' is used instead, with `cider-build-tool-files' as the extra root markers.  This works identically whether the user is in `clojure-mode', `clojure-ts-mode', or even a buffer not visiting a Clojure file (e.g. an `M-x cider-connect' from Dired), and respects any `project-find-functions' the user has configured.
+- The path-based fallback in `cider-expected-ns' no longer delegates to `clojure-expected-ns'.  Inline the same algorithm using `cider-project-dir' and a new `cider-directory-prefixes' defcustom (mirroring `clojure-directory-prefixes' but owned by cider).  No behavior change for files on the classpath (still preferred) or in a recognized project layout; removes the runtime dependency on `clojure-mode' for ns derivation.
 - [#710](https://github.com/clojure-emacs/cider-nrepl/issues/710): Use namespaced nREPL ops (e.g. `cider/info` instead of `info`) to match cider-nrepl 0.59+.
 - Bump the injected `nrepl` to [1.7.0](https://github.com/nrepl/nrepl/blob/master/CHANGELOG.md#170-2026-04-14).
 - Bump the injected `cider-nrepl` to [0.59.0](https://github.com/clojure-emacs/cider-nrepl/blob/master/CHANGELOG.md#0590-2026-04-14).

lisp/cider-client.el

@@ -152,27 +152,59 @@ Remove extension and substitute \"/\" with \".\", \"_\" with \"-\"."
     (replace-regexp-in-string "/" ".")
     (replace-regexp-in-string "_" "-")))
 
+(defcustom cider-directory-prefixes
+  '("\\`clj[scxd]?\\.")
+  "Namespace prefixes to strip after deriving a ns from a file path.
+Used by `cider-expected-ns' to discard intermediate source directories
+that aren't really part of the namespace, e.g. a file at
+\"src/clj/foo/bar.clj\" should give the namespace \"foo.bar\" rather
+than \"clj.foo.bar\"."
+  :type '(repeat string)
+  :group 'cider
+  :safe (lambda (value)
+          (and (listp value)
+               (cl-every #'stringp value))))
+
+(defun cider--ns-from-path (path)
+  "Derive a Clojure namespace from PATH using project layout heuristics.
+PATH is expected to be an absolute file path inside a project (see
+`cider-project-dir').  The first directory component of the project-
+relative path is dropped (typically `src' or `test') and any prefix
+matching an entry in `cider-directory-prefixes' is stripped from the
+result.  Returns nil when PATH isn't inside a recognized project."
+  (when-let* ((proj (cider-project-dir (file-name-directory path)))
+              (relative (file-relative-name path proj))
+              (drop-first (mapconcat #'identity
+                                     (cdr (split-string relative "/"))
+                                     "/")))
+    (cl-reduce (lambda (acc re) (replace-regexp-in-string re "" acc))
+               cider-directory-prefixes
+               :initial-value (cider-path-to-ns drop-first))))
+
 (defun cider-expected-ns (&optional path)
   "Return the namespace string matching PATH, or nil if not found.
-If PATH is nil, use the path to the file backing the current buffer.  The
-command falls back to `clojure-expected-ns' in the absence of an active
-nREPL connection."
-  (if (cider-connected-p)
-      (let* ((path (file-truename (or path buffer-file-name)))
-             (relpath (thread-last
-                        (cider-classpath-entries)
-                        (seq-filter #'file-directory-p)
-                        (seq-map (lambda (dir)
-                                   (when (file-in-directory-p path dir)
-                                     (file-relative-name path dir))))
-                        (seq-filter #'identity)
-                        (seq-sort (lambda (a b)
-                                    (< (length a) (length b))))
-                        (car))))
-        (if relpath
-            (cider-path-to-ns relpath)
-          (clojure-expected-ns path)))
-    (clojure-expected-ns path)))
+If PATH is nil, use the path to the file backing the current buffer.
+
+When an nREPL connection is active, the namespace is preferentially
+derived from the connection's classpath entries.  Otherwise (or when
+PATH isn't on the classpath) it falls back to `cider--ns-from-path',
+which uses project layout heuristics."
+  (when-let* ((path (file-truename (or path buffer-file-name))))
+    (if (cider-connected-p)
+        (let ((relpath (thread-last
+                         (cider-classpath-entries)
+                         (seq-filter #'file-directory-p)
+                         (seq-map (lambda (dir)
+                                    (when (file-in-directory-p path dir)
+                                      (file-relative-name path dir))))
+                         (seq-filter #'identity)
+                         (seq-sort (lambda (a b)
+                                     (< (length a) (length b))))
+                         (car))))
+          (if relpath
+              (cider-path-to-ns relpath)
+            (cider--ns-from-path path)))
+      (cider--ns-from-path path))))
 
 (defun cider--fallback-op (op connection)
   "Return the effective op name for OP on CONNECTION.

test/cider-client-tests.el

@@ -243,7 +243,11 @@
     (spy-on 'file-in-directory-p :and-call-fake (lambda (file dir)
                                                   (string-prefix-p dir file)))
     (spy-on 'file-relative-name :and-call-fake (lambda (file dir)
-                                                 (substring file (+ 1 (length dir))))))
+                                                 (substring file (+ 1 (length dir)))))
+    ;; The path-based fallback uses `cider-project-dir' to compute a
+    ;; relative path; stub it so we don't accidentally pick up the
+    ;; surrounding cider repo as a "project".
+    (spy-on 'cider-project-dir :and-return-value "/cider--proj/"))
 
   (it "returns the namespace matching the given string path"
     (expect (cider-expected-ns "/cider--a/foo/bar/baz_utils.clj") :to-equal
@@ -256,14 +260,22 @@
     (expect (cider-expected-ns "/cider--c/foo/bar/baz") :to-equal
             "foo.bar.baz")
     (expect (cider-expected-ns "/cider--base/clj-dev/foo/bar.clj") :to-equal
-            "foo.bar")
-    (expect (cider-expected-ns "/cider--not/in/classpath.clj") :to-equal
-            (clojure-expected-ns "/cider--not/in/classpath.clj")))
-
-  (it "returns nil if it cannot find the namespace"
-    (expect (cider-expected-ns "/cider--z/abc/def") :to-equal ""))
-
-  (it "falls back on `clojure-expected-ns' in the absence of an active nREPL connection"
+            "foo.bar"))
+
+  (it "falls back on project-relative path heuristics when the file is not on the classpath"
+    ;; With our `cider-project-dir' stub returning "/cider--proj/", the
+    ;; mocked `file-relative-name' makes "/cider--proj/src/foo/bar.clj"
+    ;; relative to "/cider--proj/" -> "src/foo/bar.clj".  The path-based
+    ;; helper drops the first directory ("src") and produces "foo.bar".
+    (expect (cider-expected-ns "/cider--proj/src/foo/bar.clj") :to-equal
+            "foo.bar"))
+
+  (it "strips known directory prefixes after deriving the ns"
+    ;; Files under e.g. src/clj/... should not produce a "clj." prefix.
+    (expect (cider-expected-ns "/cider--proj/src/clj/foo/bar.clj") :to-equal
+            "foo.bar"))
+
+  (it "uses the path-based fallback in the absence of an active nREPL connection"
     (spy-on 'cider-connected-p :and-return-value nil)
-    (spy-on 'clojure-expected-ns :and-return-value "clojure-expected-ns")
-    (expect (cider-expected-ns "foo") :to-equal "clojure-expected-ns")))
+    (expect (cider-expected-ns "/cider--proj/src/foo/bar.clj") :to-equal
+            "foo.bar")))