Appease linter gods

Author: alexander-yakushev

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))

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.")

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))))

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)

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)))

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))

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)))

cider-selector.el

@@ -120,57 +120,59 @@ is chosen.  The returned buffer is selected with
                           (cl-remove ,key cider-selector-methods :key #'car))
                     #'< :key #'car))))
 
-(def-cider-selector-method ?? "Selector help buffer."
-  (ignore-errors (kill-buffer cider-selector-help-buffer))
-  (with-current-buffer (get-buffer-create cider-selector-help-buffer)
-    (insert "CIDER Selector Methods:\n\n")
-    (cl-loop for (key line nil) in cider-selector-methods
-             do (insert (format "%c:\t%s\n" key line)))
-    (goto-char (point-min))
-    (help-mode)
-    (display-buffer (current-buffer) t))
-  (cider-selector)
-  (current-buffer))
+(def-cider-selector-method
+ ?? "Selector help buffer."
+ (ignore-errors (kill-buffer cider-selector-help-buffer))
+ (with-current-buffer (get-buffer-create cider-selector-help-buffer)
+   (insert "CIDER Selector Methods:\n\n")
+   (cl-loop for (key line nil) in cider-selector-methods
+            do (insert (format "%c:\t%s\n" key line)))
+   (goto-char (point-min))
+   (help-mode)
+   (display-buffer (current-buffer) t))
+ (cider-selector)
+ (current-buffer))
 
 (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."
-  (cider-selector--recently-visited-buffer '(clojure-mode clojure-ts-mode)))
+(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."
-  (cider-selector--recently-visited-buffer 'emacs-lisp-mode))
+(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
+ ?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)))
+ (or (cider-current-repl)
+     (cider-selector--recently-visited-buffer 'cider-repl-mode)))
 
-(def-cider-selector-method ?m
-  "Current connection's *nrepl-messages* buffer."
-  (nrepl-messages-buffer (cider-current-repl)))
+(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."
-  cider-error-buffer)
+(def-cider-selector-method
+ ?x "*cider-error* buffer."
+ cider-error-buffer)
 
-(def-cider-selector-method ?p
-  "*cider-profile* buffer."
-  cider-profile-buffer)
+(def-cider-selector-method
+ ?p "*cider-profile* buffer."
+ cider-profile-buffer)
 
-(def-cider-selector-method ?d
-  "*cider-doc* buffer."
-  cider-doc-buffer)
+(def-cider-selector-method
+ ?d "*cider-doc* buffer."
+ cider-doc-buffer)
 
-(def-cider-selector-method ?s
-  "*cider-scratch* buffer."
-  (cider-scratch-find-or-create-buffer))
+(def-cider-selector-method
+ ?s "*cider-scratch* buffer."
+ (cider-scratch-find-or-create-buffer))
 
 (provide 'cider-selector)
 

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)

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))

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)