cider-ns - refinements

CHANGELOG.md

@@ -15,6 +15,8 @@
 
 - [#3626](https://github.com/clojure-emacs/cider/issues/3626): `cider-ns-refresh`: jump to the relevant file/line on errors.
 - [#3628](https://github.com/clojure-emacs/cider/issues/3628): `cider-ns-refresh`: summarize errors as an overlay.
+- [#3628](https://github.com/clojure-emacs/cider/issues/3628): `cider-ns-refresh`: accept `clear-and-inhibit` mode.
+ - It often makes sense not to run the before/after functions around the `clear`ing.
 - Bump the injected nREPL to [1.1.1](https://github.com/nrepl/nrepl/blob/v1.1.1/CHANGELOG.md#111-2024-02-20).
 - Bump the injected `cider-nrepl` to [0.47.0](https://github.com/clojure-emacs/cider-nrepl/blob/v0.47.0/CHANGELOG.md#0470-2024-03-10).
  - Updates [Orchard](https://github.com/clojure-emacs/orchard/blob/v0.23.2/CHANGELOG.md#0232-2024-03-10).

cider-ns.el

@@ -137,8 +137,9 @@ presenting the error message as an overlay."
  ;; jars are unlikely sources of user errors, so we favor the next `cause-dict':
  (not (string-prefix-p "jar:" file-url))
  line)
- (setq buf (cider--find-buffer-for-file file-url))
- (list buf (cons line column)))))
+ (when-let ((found (cider--find-buffer-for-file file-url)))
+ (setq buf found)
+ (list buf (cons line column))))))
  error)))
  (when jump-args
  (apply #'cider-jump-to jump-args)
@@ -152,9 +153,7 @@ presenting the error message as an overlay."
  (trimmed-err (funcall cider-inline-error-message-function message)))
  (cider--display-interactive-eval-result trimmed-err
  'error
- (save-excursion
- (end-of-defun)
- (point))
+ (cider--semantic-end-of-line)
  'cider-error-overlay-face)))))
  (cider--render-stacktrace-causes error)
  ;; Select the window displaying the 'culprit' buffer so that the user can immediately fix it,
@@ -286,24 +285,27 @@ Uses the configured 'refresh dirs' \(defaults to the classpath dirs).
 With a single prefix argument, or if MODE is `refresh-all', reload all
 namespaces on the classpath dirs unconditionally.
 
-With a double prefix argument, or if MODE is `clear', clear the state of
-the namespace tracker before reloading. This is useful for recovering from
+With a double prefix argument, or if MODE is `clear' (or `clear-and-inhibit'),
+clear the state of the namespace tracker before reloading.
+
+This is useful for recovering from
 some classes of error (for example, those caused by circular dependencies)
 that a normal reload would not otherwise recover from. The trade-off of
 clearing is that stale code from any deleted files may not be completely
 unloaded.
 
-With a negative prefix argument, or if MODE is `inhibit-fns', prevent any
-refresh functions (defined in `cider-ns-refresh-before-fn' and
+With a negative prefix argument,
+or if MODE is `inhibit-fns' (or `clear-and-inhibit'),
+ prevent any refresh functions (defined in `cider-ns-refresh-before-fn' and
 `cider-ns-refresh-after-fn') from being invoked."
  (interactive "p")
  (cider-ensure-connected)
  (cider-ensure-op-supported "refresh")
  (cider-ensure-op-supported "cider.clj-reload/reload")
  (cider-ns-refresh--save-modified-buffers)
- (let ((clear? (member mode '(clear 16)))
+ (let ((clear? (member mode '(clear clear-and-inhibit 16)))
  (all? (member mode '(refresh-all 4)))
- (inhibit-refresh-fns (member mode '(inhibit-fns -1))))
+ (inhibit-refresh-fns (member mode '(inhibit-fns clear-and-inhibit -1))))
  (cider-map-repls :clj
  (lambda (conn)
  ;; Inside the lambda, so the buffer is not created if we error out.

cider-util.el

@@ -826,6 +826,28 @@ KIND can be the symbols `ns', `var', `emph', `fn', or a face name."
  (t x)))
  menu-list))
 
+(defun cider--semantic-end-of-line ()
+ "Returns POINT at the closest EOL that we can move to semantically,
+i.e. using sexp-aware navigation."
+ (let ((continue t)
+ (p (point)))
+ (save-excursion
+ (while continue
+ (end-of-line)
+ (condition-case nil
+ (save-excursion
+ ;; If we can't `clojure-backward-logical-sexp',
+ ;; it means that we aren't in a 'semantic' position,
+ ;; so functions like `cider--make-result-overlay' (which use `clojure-backward-logical-sexp' internally) would fail
+ (clojure-backward-logical-sexp))
+ (scan-error (forward-line)))
+ (setq p (point))
+ (setq continue (and (not (eolp)) ;; we're trying to move to the end of the line
+ (not (eobp)) ;; abort if we reached EOF (infinite loop avoidance)
+ (not (equal p (point))) ;; abort if we aren't moving (infinite loop avoidance)
+ )))
+ (point))))
+
 (provide 'cider-util)
 
 ;;; cider-util.el ends here

doc/modules/ROOT/pages/usage/misc_features.adoc

@@ -62,17 +62,24 @@ Typing kbd:[C-c M-n r] or kbd:[C-c M-n M-r] will invoke
 `cider-ns-refresh` and reload all modified Clojure files on the
 classpath.
 
-Adding a prefix argument, kbd:[C-u C-c M-n r], will reload all
+Adding a prefix argument, kbd:[C-u C-c M-n r], it will reload all
 the namespaces on the classpath unconditionally, regardless of their
 modification status.
 
-Adding a double prefix argument, kbd:[C-u C-u M-n r], will first
+Adding a double prefix argument, kbd:[C-u C-u M-n r], it will first
 clear the state of the namespace tracker before reloading. This is
-useful for recovering from some classes of error that normal reloads
+useful for recovering from some classes of errosr that normal reloads
 would otherwise not recover from. A good example is circular
 dependencies. The trade-off is that stale code from any deleted files
 may not be completely unloaded.
 
+Adding a negative prefix argument will inhibit
+the `cider-ns-refresh-before-fn` and `cider-ns-refresh-after-fn` functions from being run.
+
+Invoked with a programmatic `clear-and-inhibit` argument,
+it will both clear the namespace tracker before reloading (per the previous paragraph),
+and inhibit the `cider-ns-refresh-before-fn` and `cider-ns-refresh-after-fn` functions from being run.
+
 `cider-ns-refresh` wraps
 https://github.com/clojure/tools.namespace[clojure.tools.namespace], and as
 such the same

test/cider-util-tests.el

@@ -392,3 +392,68 @@ and some other vars (like clojure.core/filter).
  (expect (cider-clojure-major-mode-p) :to-be-truthy)
  (expect (cider-clojurescript-major-mode-p) :not :to-be-truthy)
  (expect (cider-clojurec-major-mode-p) :to-be-truthy))))
+
+(describe "cider--semantic-end-of-line"
+ (with-clojure-buffer "|(def foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(|def foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(de|f foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(def| foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(def |foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(def fo|o)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(def foo|)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "(def foo)|
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 10))
+
+ (with-clojure-buffer "|(def
+
+foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 5))
+
+ (with-clojure-buffer "(def
+|
+foo)
+bar
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 6))
+
+ (with-clojure-buffer "(def foo)
+bar|
+baz"
+ (expect (cider--semantic-end-of-line) :to-equal 14))
+
+ (with-clojure-buffer "(def foo)
+bar
+baz|"
+ (expect (cider--semantic-end-of-line) :to-equal 18)))