Inspect code for error and update docstrings

PillFall · PillFall · commit 5e930943ac0c · 2023-01-21T20:17:46.000-05:00
diff --git a/languagetool-console.el b/languagetool-console.el
@@ -6,7 +6,7 @@
 ;; Keywords: grammar text docs tools convenience checker
 ;; URL: https://github.com/PillFall/Emacs-LanguageTool.el
 ;; Version: 1.2.0
-;; Package-Requires: ((emacs "27.0"))
+;; Package-Requires: ((emacs "27.1"))
 
 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@@ -32,11 +32,13 @@
 (require 'languagetool-core)
 (require 'languagetool-issue)
 (require 'languagetool-java)
+(eval-when-compile
+  (require 'subr-x))
 
 ;; Group definition:
 
 (defgroup languagetool-console nil
-  "LanguageTool command line parser and checking"
+  "LanguageTool command line parser and checking."
   :tag "Console"
   :prefix "languagetool-console-"
   :group 'languagetool)
@@ -74,7 +76,7 @@ Command Line.")
 ;;; Function definitions:
 
 (defun languagetool-console-class-p ()
-  "Return nil if `languagetool-console-command' is not a Java class."
+  "Return non-nil if `languagetool-console-command' is a Java class."
   (let ((regex (rx
                 line-start
                 (zero-or-more
@@ -90,7 +92,7 @@ Command Line.")
     (string-match-p regex languagetool-console-command)))
 
 (defun languagetool-console-command-exists-p ()
-  "Return t is `languagetool-console-command' can be used or exists.
+  "Return non-nil if `languagetool-console-command' can be used or exists.
 
 Also sets `languagetool-console-command' to a full path if needed
 for this package to work."
@@ -104,63 +106,55 @@ for this package to work."
   (unless (listp languagetool-console-arguments)
     (error "LanguageTool Console Arguments must be a list of strings"))
 
-  (let ((arguments nil))
+  (let (arguments)
 
     ;; Appends LanguageTool Console Command
     (unless (languagetool-console-class-p)
-      (setq arguments (append arguments (list "-jar"))))
-    (setq arguments (append arguments (list languagetool-console-command)))
+      (push "-jar" arguments))
+    (push languagetool-console-command arguments)
 
     ;; Appends the LanguageTool arguments
-    (setq arguments (append arguments languagetool-console-arguments))
+    (push languagetool-console-arguments arguments)
 
     ;; Appends the common arguments
-    (setq arguments (append arguments
-                            (list "--encoding" "utf8")
-                            (list "--json")))
+    (push (list "--encoding" "utf8" "--json") arguments)
 
     ;; Appends the correction language information
     (if (string= languagetool-correction-language "auto")
-        (setq arguments (append arguments (list "--autoDetect")))
-      (setq arguments (append arguments (list "--language" languagetool-correction-language))))
+        (push "--autoDetect" arguments)
+      (push (list "--language" languagetool-correction-language) arguments))
 
     ;; Appends the mother tongue information
     (when (stringp languagetool-mother-tongue)
-      (setq arguments (append arguments (list "--mothertongue" languagetool-mother-tongue))))
+      (push (list "--mothertongue" languagetool-mother-tongue) arguments))
 
     ;; Appends the disabled rules
-    (let ((rules ""))
-      ;; Global disabled rules
-      (dolist (rule languagetool-disabled-rules)
-        (if (string= rules "")
-            (setq rules (concat rules rule))
-          (setq rules (concat rules "," rule))))
-      ;; Local disabled rules
-      (dolist (rule languagetool-local-disabled-rules)
-        (if (string= rules "")
-            (setq rules (concat rules rule))
-          (setq rules (concat rules "," rule))))
+    (let ((rules (string-join (append languagetool-disabled-rules languagetool-local-disabled-rules) ",")))
       (unless (string= rules "")
-        (setq arguments (append arguments (list "--disable" rules)))))
-    arguments))
+        (push (list "--disable" rules) arguments )))
+    (flatten-tree (reverse arguments))))
 
 (defun languagetool-console-write-debug-info (text)
   "Write debug info in `languagetool-console-output-buffer-name'.
 
 The argument TEXT is the region passed to LanguageTool for
 checking."
-  (insert (propertize " ----- LanguageTool Command:" 'face 'font-lock-warning-face)
-          "\n\n")
-  (insert languagetool-java-bin " "
-          (mapconcat (lambda (x) (format "%s" x)) (append
-                                              (languagetool-console-parse-arguments)
-                                              (languagetool-java-parse-arguments)) " ")
-          "\n\n\n\n")
-  (insert (propertize " ----- LanguageTool Text:" 'face 'font-lock-warning-face)
-          "\n\n")
-  (insert text "\n\n\n\n")
-  (insert (propertize " ----- LanguageTool Output:" 'face 'font-lock-warning-face)
-          "\n\n"))
+  (insert
+   (propertize " ----- LanguageTool Command:" 'face 'font-lock-warning-face)
+   "\n\n"
+   (string-join
+    (append
+     (list languagetool-java-bin)
+     (languagetool-java-parse-arguments)
+     (languagetool-console-parse-arguments))
+    " ")
+   "\n\n\n\n"
+   (propertize " ----- LanguageTool Text:" 'face 'font-lock-warning-face)
+   "\n\n"
+   text
+   "\n\n\n\n"
+   (propertize " ----- LanguageTool Output:" 'face 'font-lock-warning-face)
+   "\n\n"))
 
 (defun languagetool-console-invoke-command-region (begin end)
   "Invoke LanguageTool passing the current region to STDIN.
@@ -219,17 +213,17 @@ Found no errors.")
 
 (defun languagetool-console-matches-exists-p ()
   "Return t if issues where found by LanguageTool or nil otherwise."
-  (/= 0 (length (cdr (assoc 'matches languagetool-console-output-parsed)))))
+  (/= 0 (length (alist-get 'matches languagetool-console-output-parsed))))
 
 (defun languagetool-console-highlight-matches (begin)
   "Highlight issues in the buffer.
 
 BEGIN defines the start of the current region."
-  (let ((corrections (cdr (assoc 'matches languagetool-console-output-parsed))))
+  (let ((corrections (alist-get 'matches languagetool-console-output-parsed)))
     (dotimes (index (length corrections))
       (let* ((correction (aref corrections index))
-             (offset (cdr (assoc 'offset correction)))
-             (size (cdr (assoc 'length correction)))
+             (offset (alist-get 'offset correction))
+             (size (alist-get 'length correction))
              (start (+ begin offset))
              (end (+ begin offset size))
              (word (buffer-substring-no-properties start end)))
diff --git a/languagetool-core.el b/languagetool-core.el
@@ -6,7 +6,7 @@
 ;; Keywords: grammar text docs tools convenience checker
 ;; URL: https://github.com/PillFall/Emacs-LanguageTool.el
 ;; Version: 1.2.0
-;; Package-Requires: ((emacs "27.0"))
+;; Package-Requires: ((emacs "27.1"))
 
 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@@ -30,6 +30,8 @@
 ;; Variable definitions:
 
 (require 'ispell)
+(eval-when-compile
+  (require 'subr-x))
 
 (defcustom languagetool-api-key nil
   "LanguageTool API Key for Premium features."
@@ -165,13 +167,12 @@ A example hint function:
     (when (overlay-get ov 'languagetool-message)
       (unless (current-message)
         (message
-         \"%s%s\" (overlay-get ov 'languagetool-short-message)
-         (if (/= 0
-                 (length (overlay-get ov 'languagetool-replacements)))
+         \"%s%s\"
+         (overlay-get ov 'languagetool-short-message)
+         (if (/= 0 (length (overlay-get ov 'languagetool-replacements)))
              (concat
               \" -> (\"
-              (mapconcat
-               #'identity (languagetool-core-get-replacements ov) \", \")
+              (string-join (languagetool-core-get-replacements ov) \", \")
               \")\")
            \"\"))))))"
   :group 'languagetool
@@ -208,30 +209,28 @@ A example hint function:
     (when (overlay-get ov 'languagetool-message)
       (unless (current-message)
         (message
-         "%s%s" (overlay-get ov 'languagetool-short-message)
-         (if (/= 0
-                 (length (overlay-get ov 'languagetool-replacements)))
+         "%s%s"
+         (overlay-get ov 'languagetool-short-message)
+         (if (/= 0 (length (overlay-get ov 'languagetool-replacements)))
              (concat
               " -> ("
-              (mapconcat
-               #'identity (languagetool-core-get-replacements ov) ", ")
+              (string-join (languagetool-core-get-replacements ov) ", ")
               ")")
            ""))))))
 
 (defun languagetool-core-get-replacements (overlay)
   "Return the replacements of OVERLAY in a list."
   (let ((replacements (overlay-get overlay 'languagetool-replacements))
-        (replace nil))
+        replace)
     (dotimes (index (length replacements))
-      (setq replace (append replace
-                            (list (cdr (assoc 'value (aref replacements index)))))))
-    replace))
+      (push (alist-get 'value (aref replacements index)) replace))
+    (reverse replace)))
 
 (defun languagetool-core-correct-p (word)
-  "Check if WORD is assumed correct in the current buffer."
+  "Return non-nil if WORD is on the LocalWords comment in the current buffer."
   (save-excursion
     (goto-char (point-min))
-    (let ((found nil))
+    (let (found)
       (while (and (search-forward ispell-words-keyword nil t)
                   (not found))
 	(when (re-search-forward (rx
diff --git a/languagetool-correction.el b/languagetool-correction.el
@@ -6,7 +6,7 @@
 ;; Keywords: grammar text docs tools convenience checker
 ;; URL: https://github.com/PillFall/Emacs-LanguageTool.el
 ;; Version: 1.2.0
-;; Package-Requires: ((emacs "27.0"))
+;; Package-Requires: ((emacs "27.1"))
 
 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@@ -48,52 +48,54 @@
   "Parse and style minibuffer correction.
 
 Get the information about corrections from OVERLAY."
-  (let ((msg nil)
-        (rule (cdr (assoc 'id (overlay-get overlay 'languagetool-rule))))
-        (message (overlay-get overlay 'languagetool-message)))
+  (let* ((msg nil)
+        (rule (alist-get 'id (overlay-get overlay 'languagetool-rule)))
+        (message (overlay-get overlay 'languagetool-message))
+        (replacements (languagetool-core-get-replacements overlay))
+        (num-choices (length replacements)))
     ;; Add LanguageTool rule to the message
     (setq msg (concat msg "[" rule "] "))
 
     ;; Add LanguageTool correction suggestion
     (setq msg (concat msg (propertize (format "%s" message) 'face 'font-lock-warning-face) "\n"))
 
     ;; Format all the possible replacements for the correction suggestion
-    (let ((replacements (languagetool-core-get-replacements overlay)))
-      (when (< 0 (length replacements))
-        (let ((num-choices (length replacements)))
-          ;; If can't assoc each replacement with each hotkey
-          (when (> (length replacements) (length languagetool-correction-keys))
-            (setq num-choices (length languagetool-correction-keys))
-            (setq msg (concat msg "Not all choices shown.\n")))
-          (setq msg (concat msg "\n"))
-          ;; Format all choices
-          (dotimes (index num-choices)
-            (setq msg (concat msg
-                              "["
-                              (propertize
-                               (format "%c" (aref languagetool-correction-keys index))
-                               'face 'font-lock-keyword-face)
-                              "]: "))
-            (setq msg (concat msg (nth index replacements) "  "))))))
+    ;; If can't assoc each replacement with each hotkey truncate the replacements
+    (when (> (length replacements) (length languagetool-correction-keys))
+      (setq num-choices (length languagetool-correction-keys))
+      (setq msg (concat msg "Not all choices shown.\n")))
+    (setq msg (concat msg "\n"))
+    ;; Format all choices
+    (dotimes (index num-choices)
+      (setq msg (concat msg
+                        "["
+                        (propertize
+                         (format "%c" (aref languagetool-correction-keys index))
+                         'face 'font-lock-keyword-face)
+                        "]: "))
+      (setq msg (concat msg (nth index replacements) "  ")))
     ;; Add default Ignore and Skip options
     (setq msg (concat msg "\n["
                       (propertize "C-i" 'face 'font-lock-keyword-face)
                       "]: Ignore  "))
     (setq msg (concat msg "["
                       (propertize "C-s" 'face 'font-lock-keyword-face)
-                      "]: Skip\n"))
-    msg))
+                      "]: Skip  "))
+    ;; Some people do not know C-g is the global exit key
+    (setq msg (concat msg "["
+                      (propertize "C-g" 'face 'font-lock-keyword-face)
+                      "]: Quit\n"))))
 
 (defun languagetool-correction-apply (pressed-key overlay)
-  "Correct text marked by LanguageTool with user choice.
+  "Apply LanguageTool replacement suggestion in OVERLAY.
 
 PRESSED-KEY is the index of the suggestion in the array contained
 on OVERLAY."
   (cond
    ((char-equal ?\C-i pressed-key)
     (progn
       (goto-char (overlay-end overlay))
-      (ispell-add-per-file-word-list (buffer-substring-no-properties (overlay-end overlay) (overlay-start overlay)))
+      (ispell-add-per-file-word-list (buffer-substring-no-properties (overlay-start overlay) (overlay-end overlay)))
       (delete-overlay overlay)))
    ((char-equal ?\C-s pressed-key)
     (goto-char (overlay-end overlay)))
@@ -110,13 +112,13 @@ on OVERLAY."
 
 (defun languagetool-correction-at-point ()
   "Show issue at point and try to apply suggestion."
-  (let (pressed-key)
-    (dolist (ov (overlays-at (point)))
-      (when (overlay-get ov 'languagetool-message)
-        (message nil)
-        (setq pressed-key
-              (read-char (languagetool-correction-parse-message ov)))
-        (languagetool-correction-apply pressed-key ov)))))
+  (dolist (ov (overlays-at (point)))
+    (when (overlay-get ov 'languagetool-message)
+      ;; Cancel any previous message
+      (message nil)
+      (languagetool-correction-apply
+       (read-char (languagetool-correction-parse-message ov))
+       ov))))
 
 (provide 'languagetool-correction)
 
diff --git a/languagetool-issue.el b/languagetool-issue.el
@@ -6,7 +6,7 @@
 ;; Keywords: grammar text docs tools convenience checker
 ;; URL: https://github.com/PillFall/Emacs-LanguageTool.el
 ;; Version: 1.2.0
-;; Package-Requires: ((emacs "27.0"))
+;; Package-Requires: ((emacs "27.1"))
 
 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@@ -37,7 +37,7 @@
 ;; Group definition:
 
 (defgroup languagetool-issue nil
-  "LanguageTool faces for marking issues"
+  "LanguageTool faces for marking issues."
   :tag "Issue Faces"
   :prefix "languagetool-issue-"
   :group 'languagetool)
@@ -92,7 +92,7 @@ Each element is a cons cell with the form (ISSUE_TYPE . FACE_NAME)."
 
 (defun languagetool-issue-get-face (issue-type)
   "Return the face for ISSUE-TYPE."
-  (or (cdr (assoc issue-type languagetool-issue-face-alist))
+  (or (alist-get issue-type languagetool-issue-face-alist)
       'languagetool-issue-default))
 
 (defun languagetool-issue-create-overlay (begin end correction)
@@ -102,11 +102,11 @@ Create an overlay for correction in the region delimited by BEGIN
 and END, parsing CORRECTION as overlay properties."
   (save-excursion
     (let* ((ov (make-overlay begin end))
-           (short-message (cdr (assoc 'shortMessage correction)))
-           (message (cdr (assoc 'message correction)))
-           (replacements (cdr (assoc 'replacements correction)))
-           (rule (cdr (assoc 'rule correction)))
-           (issue-type (cdr (assoc 'issueType rule))))
+           (short-message (alist-get 'shortMessage correction))
+           (message (alist-get 'message correction))
+           (replacements (alist-get 'replacements correction))
+           (rule (alist-get 'rule correction))
+           (issue-type (alist-get 'issueType rule)))
       (when (string= short-message "")
         (setq short-message message))
       (overlay-put ov 'languagetool-short-message short-message)
diff --git a/languagetool-java.el b/languagetool-java.el
diff --git a/languagetool-server.el b/languagetool-server.el
