Appease linter gods

alexander-yakushev · alexander-yakushev · commit d7b5486595f7 · 2025-03-04T15:57:55.000+02:00
diff --git a/cider-browse-ns.el b/cider-browse-ns.el
@@ -268,10 +268,10 @@ list of items."
   (let* ((max-length (cider-browse-ns--column-width items)))
     (cl-labels
         ((keys-from-pred
-          (pred items)
-          (nrepl-dict-keys (nrepl-dict-filter (lambda (_ var-meta)
-                                                (funcall pred var-meta))
-                                              items))))
+           (pred items)
+           (nrepl-dict-keys (nrepl-dict-filter (lambda (_ var-meta)
+                                                 (funcall pred var-meta))
+                                               items))))
       (cond
        ((eql cider-browse-ns-group-by 'type)
         (let* ((func-keys (keys-from-pred #'cider-browse-ns--meta-function-p items))
diff --git a/cider-client.el b/cider-client.el
@@ -249,15 +249,15 @@ Assuming this is the Clojure map you want to use as `cljfmt' options:
 
 you need to encode it as the following plist:
 
-  '((\"indents\" ((\"org.me/foo\" ((\"inner\" 0))))) (\"alias-map\" ((\"me\" \"org.me\"))))"
+  \\='((\"indents\" ((\"org.me/foo\" ((\"inner\" 0))))) (\"alias-map\" ((\"me\" \"org.me\"))))"
   :type 'list
   :group 'cider
   :package-version '(cider . "1.1.0"))
 
 (defun cider--nrepl-format-code-request-map (&optional format-options)
   "Map to merge into requests that require code formatting.
 If non-nil, FORMAT-OPTIONS specifies the options cljfmt will use to format
-the code.  See `cider-format-code-options` for details."
+the code.  See `cider-format-code-options' for details."
   (when format-options
     (let* ((indents-dict (when (assoc "indents" format-options)
                            (thread-last
@@ -320,7 +320,7 @@ nil."
   "A map of options that will be passed to `cider-print-fn'.
 Here's an example for `pprint':
 
-  '((\"length\" 50) (\"right-margin\" 70))"
+  \\='((\"length\" 50) (\"right-margin\" 70))"
   :type 'list
   :group 'cider
   :package-version '(cider . "0.21.0"))
diff --git a/cider-connection.el b/cider-connection.el
@@ -264,7 +264,7 @@ We look only at the major and minor components.  When the major
 version is 0, only check that the minor versions match.  When the major version
 is > 0, first check that the major version matches, then that the minor
 version is >= the required minor version.
-VER the 'installed' version,
+VER the `installed' version,
 REQUIRED-VER the version required by cider."
   (let ((ver* (cider--strip-version-patch ver))
         (required-ver* (cider--strip-version-patch required-ver)))
@@ -785,7 +785,7 @@ Session name can be customized with `cider-session-name-template'."
 ;;; REPL Buffer Init
 
 (defvar-local cider-cljs-repl-type nil
-  "The type of the ClojureScript runtime ('browser, 'node, 'figwheel, etc.).")
+  "The type of the ClojureScript runtime (browser, node, figwheel, etc.).")
 
 (defvar-local cider-repl-type nil
   "The type of this REPL buffer, usually either clj or cljs.")
diff --git a/cider-doc.el b/cider-doc.el
@@ -448,10 +448,10 @@ in a COMPACT format is specified, FOR-TOOLTIP if specified."
     (cider--help-setup-xref (list #'cider-doc-lookup (format "%s/%s" ns name)) nil buffer)
     (with-current-buffer buffer
       (cl-flet ((emit (text &optional face sep)
-                      (insert (if face
-                                  (propertize text 'font-lock-face face)
-                                text)
-                              (or sep "\n"))))
+                  (insert (if face
+                              (propertize text 'font-lock-face face)
+                            text)
+                          (or sep "\n"))))
         (emit (if class java-name clj-name) 'font-lock-function-name-face)
         (when super
           (emit (concat "Extends: " (cider-font-lock-as 'java-mode super))))
diff --git a/cider-eval.el b/cider-eval.el
@@ -222,12 +222,12 @@ _ARG and _RESET are ignored, as there is only ever one compilation error.
 They exist for compatibility with `next-error'."
   (interactive)
   (cl-labels ((goto-next-note-boundary
-               ()
-               (let ((p (or (cider-find-property 'cider-note-p)
-                            (cider-find-property 'cider-note-p t))))
-                 (when p
-                   (goto-char p)
-                   (message "%s" (get-char-property p 'cider-note))))))
+                ()
+                (let ((p (or (cider-find-property 'cider-note-p)
+                             (cider-find-property 'cider-note-p t))))
+                  (when p
+                    (goto-char p)
+                    (message "%s" (get-char-property p 'cider-note))))))
     ;; if we're already on a compilation error, first jump to the end of
     ;; it, so that we find the next error.
     (when (get-char-property (point) 'cider-note-p)
diff --git a/cider-mode.el b/cider-mode.el
@@ -789,40 +789,41 @@ with the given LIMIT."
         deprecated enlightened
         macros functions vars instrumented traced)
     (cl-labels ((handle-plist
-                 (plist)
-                 ;; Note that (memq 'function cider-font-lock-dynamically) and similar statements are evaluated differently
-                 ;; for `core' - they're always truthy for `core' (see related core-handling code some lines below):
-                 (let ((do-function (memq 'function cider-font-lock-dynamically))
-                       (do-var (memq 'var cider-font-lock-dynamically))
-                       (do-macro (memq 'macro cider-font-lock-dynamically))
-                       (do-deprecated (memq 'deprecated cider-font-lock-dynamically)))
-                   (while plist
-                     (let ((sym (pop plist))
-                           (meta (pop plist)))
-                       (pcase (nrepl-dict-get meta "cider/instrumented")
-                         (`nil nil)
-                         (`"\"breakpoint-if-interesting\""
-                          (push sym instrumented))
-                         (`"\"light-form\""
-                          (push sym enlightened)))
-                       ;; The ::traced keywords can be inlined by MrAnderson, so
-                       ;; we catch that case too.
-                       ;; FIXME: This matches values too, not just keys.
-                       (when (seq-find (lambda (k) (and (stringp k)
-                                                        (string-match (rx "orchard.trace/traced" eos) k)))
-                                       meta)
-                         (push sym traced))
-                       (when (and do-deprecated (nrepl-dict-get meta "deprecated"))
-                         (push sym deprecated))
-                       (let ((is-macro (nrepl-dict-get meta "macro"))
-                             (is-function (or (nrepl-dict-get meta "fn")
-                                              (nrepl-dict-get meta "arglists"))))
-                         (cond ((and do-macro is-macro)
-                                (push sym macros))
-                               ((and do-function is-function)
-                                (push sym functions))
-                               ((and do-var (not is-function) (not is-macro))
-                                (push sym vars)))))))))
+                  (plist)
+                  ;; Note that (memq 'function cider-font-lock-dynamically) and similar statements are evaluated differently
+                  ;; for `core' - they're always truthy for `core' (see related core-handling code some lines below):
+                  (let ((do-function (memq 'function cider-font-lock-dynamically))
+                        (do-var (memq 'var cider-font-lock-dynamically))
+                        (do-macro (memq 'macro cider-font-lock-dynamically))
+                        (do-deprecated (memq 'deprecated cider-font-lock-dynamically)))
+                    (while plist
+                      (let ((sym (pop plist))
+                            (meta (pop plist)))
+                        (pcase (nrepl-dict-get meta "cider/instrumented")
+                          (`nil nil)
+                          (`"\"breakpoint-if-interesting\""
+                           (push sym instrumented))
+                          (`"\"light-form\""
+                           (push sym enlightened)))
+                        ;; The ::traced keywords can be inlined by MrAnderson, so
+                        ;; we catch that case too.
+                        ;; FIXME: This matches values too, not just keys.
+                        (when (seq-find (lambda (k)
+                                          (and (stringp k)
+                                               (string-match (rx "orchard.trace/traced" eos) k)))
+                                        meta)
+                          (push sym traced))
+                        (when (and do-deprecated (nrepl-dict-get meta "deprecated"))
+                          (push sym deprecated))
+                        (let ((is-macro (nrepl-dict-get meta "macro"))
+                              (is-function (or (nrepl-dict-get meta "fn")
+                                               (nrepl-dict-get meta "arglists"))))
+                          (cond ((and do-macro is-macro)
+                                 (push sym macros))
+                                ((and do-function is-function)
+                                 (push sym functions))
+                                ((and do-var (not is-function) (not is-macro))
+                                 (push sym vars)))))))))
       ;; For core members, we override `cider-font-lock-dynamically', since all core members should get the same treatment:
       (when (memq 'core cider-font-lock-dynamically)
         (let ((cider-font-lock-dynamically '(function var macro core deprecated)))
diff --git a/cider-ns.el b/cider-ns.el
@@ -166,13 +166,13 @@ presenting the error message as an overlay."
   "Refresh LOG-BUFFER with RESPONSE."
   (nrepl-dbind-response response (out err reloading progress status error error-ns after before)
     (cl-flet* ((log (message &optional face)
-                    (cider-emit-into-popup-buffer log-buffer message face t))
+                 (cider-emit-into-popup-buffer log-buffer message face t))
 
                (log-echo (message &optional face)
-                         (log message face)
-                         (unless cider-ns-refresh-show-log-buffer
-                           (let ((message-truncate-lines t))
-                             (message "cider-ns-refresh: %s" message)))))
+                 (log message face)
+                 (unless cider-ns-refresh-show-log-buffer
+                   (let ((message-truncate-lines t))
+                     (message "cider-ns-refresh: %s" message)))))
       (cond
        (out
         (log out))
diff --git a/cider-repl.el b/cider-repl.el
@@ -348,11 +348,11 @@ description transform) where transform is called with the param-value if
 present."
   (cl-labels
       ((emit-comment
-        (contents)
-        (insert-before-markers
-         (propertize
-          (if (string-blank-p contents) ";;\n" (concat ";; " contents "\n"))
-          'font-lock-face 'font-lock-comment-face))))
+         (contents)
+         (insert-before-markers
+          (propertize
+           (if (string-blank-p contents) ";;\n" (concat ";; " contents "\n"))
+           'font-lock-face 'font-lock-comment-face))))
     (let ((jack-in-command (plist-get cider-launch-params :jack-in-cmd))
           (cljs-repl-type (plist-get cider-launch-params :cljs-repl-type))
           (cljs-init-form (plist-get cider-launch-params :repl-init-form)))
diff --git a/cider-selector.el b/cider-selector.el
@@ -104,6 +104,7 @@ selects a buffer.
 BODY is a series of forms which are evaluated when the selector
 is chosen.  The returned buffer is selected with
 `switch-to-buffer'."
+  (declare (indent 1))
   (let ((method `(lambda ()
                    (let ((buffer (progn ,@body)))
                      (cond ((not (and buffer (get-buffer buffer)))
@@ -135,41 +136,33 @@ is chosen.  The returned buffer is selected with
 (cl-pushnew (list ?4 "Select in other window" (lambda () (cider-selector t)))
             cider-selector-methods :key #'car)
 
-(def-cider-selector-method ?c
-  "Most recently visited clojure-mode buffer."
+(def-cider-selector-method ?c "Most recently visited clojure-mode buffer."
   (cider-selector--recently-visited-buffer '(clojure-mode clojure-ts-mode)))
 
-(def-cider-selector-method ?e
-  "Most recently visited emacs-lisp-mode buffer."
+(def-cider-selector-method ?e "Most recently visited emacs-lisp-mode buffer."
   (cider-selector--recently-visited-buffer 'emacs-lisp-mode))
 
 (def-cider-selector-method ?q "Abort."
   (top-level))
 
-(def-cider-selector-method ?r
-  "Current REPL buffer or as a fallback, the most recently
+(def-cider-selector-method ?r "Current REPL buffer or as a fallback, the most recently
 visited cider-repl-mode buffer."
   (or (cider-current-repl)
       (cider-selector--recently-visited-buffer 'cider-repl-mode)))
 
-(def-cider-selector-method ?m
-  "Current connection's *nrepl-messages* buffer."
+(def-cider-selector-method ?m "Current connection's *nrepl-messages* buffer."
   (nrepl-messages-buffer (cider-current-repl)))
 
-(def-cider-selector-method ?x
-  "*cider-error* buffer."
+(def-cider-selector-method ?x "*cider-error* buffer."
   cider-error-buffer)
 
-(def-cider-selector-method ?p
-  "*cider-profile* buffer."
+(def-cider-selector-method ?p "*cider-profile* buffer."
   cider-profile-buffer)
 
-(def-cider-selector-method ?d
-  "*cider-doc* buffer."
+(def-cider-selector-method ?d "*cider-doc* buffer."
   cider-doc-buffer)
 
-(def-cider-selector-method ?s
-  "*cider-scratch* buffer."
+(def-cider-selector-method ?s "*cider-scratch* buffer."
   (cider-scratch-find-or-create-buffer))
 
 (provide 'cider-selector)
diff --git a/cider-stacktrace.el b/cider-stacktrace.el
@@ -346,9 +346,9 @@ filters for the resulting machinery."
     (save-excursion
       (goto-char (point-min))
       (cl-flet ((next-detail (end)
-                             (when-let* ((pos (next-single-property-change (point) 'detail)))
-                               (when (< pos end)
-                                 (goto-char pos)))))
+                  (when-let* ((pos (next-single-property-change (point) 'detail)))
+                    (when (< pos end)
+                      (goto-char pos)))))
         (let ((inhibit-read-only t))
           ;; For each cause...
           (while (cider-stacktrace-next-cause)
diff --git a/nrepl-client.el b/nrepl-client.el
@@ -833,13 +833,13 @@ to the REPL."
                                            truncated-handler)
   "Make a response handler for connection BUFFER.
 A handler is a function that takes one argument - response received from
-the server process.  The response is an alist that contains at least 'id'
-and 'session' keys.  Other standard response keys are 'value', 'out', 'err',
-and 'status'.
+the server process.  The response is an alist that contains at least `id'
+and `session' keys.  Other standard response keys are `value', `out', `err',
+and `status'.
 
 The presence of a particular key determines the type of the response.  For
-example, if 'value' key is present, the response is of type 'value', if
-'out' key is present the response is 'stdout' etc.
+example, if `value' key is present, the response is of type `value', if
+`out' key is present the response is `stdout' etc.
 
 Depending on the type, the handler dispatches the appropriate value to one
 of the supplied handlers: VALUE-HANDLER, STDOUT-HANDLER, STDERR-HANDLER,
@@ -926,7 +926,7 @@ the standard session."
     (when-let* ((session (if tooling nrepl-tooling-session nrepl-session)))
       (setq request (append request `("session" ,session))))
     (let* ((id (nrepl-next-request-id connection))
-           (request (cons 'dict (lax-plist-put request "id" id)))
+           (request (cons 'dict (plist-put request "id" id #'equal)))
            (message (nrepl-bencode request)))
       (nrepl-log-message request 'request)
       (puthash id callback nrepl-pending-requests)
@@ -1219,7 +1219,7 @@ up."
 (defun nrepl-server-sentinel (process event)
   "Handle nREPL server PROCESS EVENT.
 If the nREPL PROCESS failed to initiate and encountered a fatal EVENT
-signal, raise an 'error'.  Additionally, if the EVENT signal is SIGHUP,
+signal, raise an `error'.  Additionally, if the EVENT signal is SIGHUP,
 close any existing client connections."
   ;; only interested on fatal signals.
   (when (not (process-live-p process))
@@ -1316,8 +1316,9 @@ described by `nrepl-message-buffer-name-template'."
     ;; append a time-stamp to the message before logging it
     ;; the time-stamps are quite useful for debugging
     (setq msg (cons (car msg)
-                    (lax-plist-put (cdr msg) "time-stamp"
-                                   (format-time-string "%Y-%m-%0d %H:%M:%S.%N"))))
+                    (plist-put (cdr msg) "time-stamp"
+                               (format-time-string "%Y-%m-%0d %H:%M:%S.%N")
+                               #'equal)))
     (with-current-buffer (nrepl-messages-buffer (current-buffer))
       (setq buffer-read-only nil)
       (when (> (buffer-size) nrepl-message-buffer-max-size)
@@ -1326,7 +1327,7 @@ described by `nrepl-message-buffer-name-template'."
         (delete-region (point-min) (- (point) 1)))
       (goto-char (point-max))
       (nrepl-log-pp-object (nrepl-decorate-msg msg type)
-                           (nrepl-log--message-color (lax-plist-get (cdr msg) "id"))
+                           (nrepl-log--message-color (plist-get (cdr msg) "id" #'equal))
                            t)
       (when-let* ((win (get-buffer-window)))
         (set-window-point win (point-max)))
@@ -1411,9 +1412,9 @@ If ID is nil, return nil."
   "Pretty print nREPL list like OBJECT.
 FOREGROUND and BUTTON are as in `nrepl-log-pp-object'."
   (cl-flet ((color (str)
-                   (propertize str 'face
-                               (append '(:weight ultra-bold)
-                                       (when foreground `(:foreground ,foreground))))))
+              (propertize str 'face
+                          (append '(:weight ultra-bold)
+                                  (when foreground `(:foreground ,foreground))))))
     (let ((head (format "(%s" (car object))))
       (insert (color head))
       (if (null (cdr object))
diff --git a/nrepl-dict.el b/nrepl-dict.el
@@ -73,7 +73,7 @@ removed in a future release."
     (if (nrepl-dict-p dict)
         ;; Note: The structure of the following expression avoids the
         ;; expensive containment check in nearly all cases, see #3717
-        (or (lax-plist-get (cdr dict) key)
+        (or (plist-get (cdr dict) key #'equal)
             ;; TODO: remove DEFAULT argument and the following clause
             (when default
               (and (not (nrepl-dict-contains dict key))
@@ -87,7 +87,7 @@ Return new dict.  Dict is modified by side effects."
       `(dict ,key ,value)
     (if (not (nrepl-dict-p dict))
         (error "Not an nREPL dict object: %s" dict)
-      (setcdr dict (lax-plist-put (cdr dict) key value))
+      (setcdr dict (plist-put (cdr dict) key value #'equal))
       dict)))
 
 (defun nrepl-dict-keys (dict)
