bug#65605: [PATCH] Command and option to make Edmacro better for long sequences

[Okamsn via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>]

[-- Attachment #1: Type: text/plain, Size: 1197 bytes --]

Eli Zaretskii wrote:
> If these commands are indeed important conveniences, they should be in
> the manual, I think.

I have described the new command and `edmacro-insert-key` in the manual.

> Defcustoms should have the :version tag.

I have given it as "30.1".

> 
>> +(defun edmacro-set-macro-to-region-lines (beg end)
>> +  "Set the Macro text to the lines of the region.
> 
> We prefer to have the mandatory arguments mentioned in the first line
> of a function's doc string.
> 
>> +If BEG is not at the beginning of a line, it is moved to the
>> +beginning of the line.  If END is at the beginning of a line,
>> +that line is excluded.  Otherwise, if END is not at the
>> +end of a line, it is moved to the end of the line."
> 
> This describes the implementation, whereas this is a command, so the
> doc string should have users, not programmer's in mind.  Try to
> describe BEG and END in user-level terms, for example:
> 
>    Macro text will start and the beginning of line containing buffer
>    position BEG.
> 
> Also, the doc string should tell how BEG and END are determined in
> interactive invocations.
> 

I have changed it. How does it look now?

[-- Attachment #2: v3-0001-Make-using-Edmacro-better-for-long-sequences-of-k.patch --]
[-- Type: text/x-patch, Size: 10361 bytes --]

From f1365193df83f7a765abc95507bbddb0d5d5a929 Mon Sep 17 00:00:00 2001
From: Earl Hyatt <okamsn@protonmail.com>
Date: Sat, 19 Aug 2023 18:26:45 -0400
Subject: [PATCH v3] Make using Edmacro better for long sequences of keys.

* lisp/edmacro.el (edmacro-set-macro-to-region-lines,
edmacro-reverse-key-order): New command and user option to
make working with longer lists of keys (such as from
'kmacro-edit-lossage') easier.
(edit-kbd-macro): Move regexps used to identify parts of buffer
to internal variables.
(edmacro--macro-lines-regexp, edmacro-mode-font-lock-keywords): Allow
noting whether the most recent line of keys is displayed first.
(edmacro-mode-map): Bind the new command to 'C-c C-r'.
(edmacro-mode): Describe the new command in the mode documentation
string.

* doc/emacs/kmacro.texi (Edit Keyboard Macro): Mention
'edmacro-insert-key' and the newly added
'edmacro-set-macro-to-region-lines'.
---
 doc/emacs/kmacro.texi |  11 ++++
 lisp/edmacro.el       | 113 ++++++++++++++++++++++++++++++++++++++----
 2 files changed, 113 insertions(+), 11 deletions(-)

diff --git a/doc/emacs/kmacro.texi b/doc/emacs/kmacro.texi
index fc1402b489d..30201cc71c3 100644
--- a/doc/emacs/kmacro.texi
+++ b/doc/emacs/kmacro.texi
@@ -515,6 +515,17 @@ Edit Keyboard Macro
 of how to edit the macro.  When you are finished editing, type
 @kbd{C-c C-c}.
 
+@findex edmacro-insert-key
+@findex edmacro-set-macro-to-region-lines
+  The mode provides commands for more easily editing the formatted
+macro.  Use @kbd{C-c C-q} (@code{edmacro-insert-key}) to insert the
+next key sequence that you type into the buffer using the correct
+format, similar to @kbd{C-q} (@code{quoted-insert}).  Use @kbd{C-c
+C-r} (@code{edmacro-set-macro-to-region-lines}) to replace the macro's
+formatted text with the lines overlapping the region of text between
+point and mark.  If the region ends at the beginning of a line, that
+final line is excluded.
+
 @findex edit-kbd-macro
 @kindex C-x C-k e
   You can edit a named keyboard macro or a macro bound to a key by typing
diff --git a/lisp/edmacro.el b/lisp/edmacro.el
index bbf5a7f0495..9bc37e47622 100644
--- a/lisp/edmacro.el
+++ b/lisp/edmacro.el
@@ -73,9 +73,19 @@ edmacro-eight-bits
   :type 'boolean
   :group 'kmacro)
 
+(defcustom edmacro-reverse-key-order nil
+  "Non-nil if `edit-kbd-macro' should show the most recent line of keys first.
+
+This is useful when dealing with long lists of key sequences, such as
+from `kmacro-edit-lossage'."
+  :type 'boolean
+  :group 'kmacro
+  :version "30.1")
+
 (defvar-keymap edmacro-mode-map
   "C-c C-c" #'edmacro-finish-edit
-  "C-c C-q" #'edmacro-insert-key)
+  "C-c C-q" #'edmacro-insert-key
+  "C-c C-r" #'edmacro-set-macro-to-region-lines)
 
 (defface edmacro-label
   '((default :inherit bold)
@@ -88,7 +98,10 @@ edmacro-label
   :group 'kmacro)
 
 (defvar edmacro-mode-font-lock-keywords
-  `((,(rx bol (group (or "Command" "Key" "Macro") ":")) 0 'edmacro-label)
+  `((,(rx bol (group (or "Command" "Key"
+                         (seq "Macro" (zero-or-one " (most recent line first)")))
+                     ":"))
+     0 'edmacro-label)
     (,(rx bol
           (group ";; Keyboard Macro Editor.  Press ")
           (group (*? nonl))
@@ -166,7 +179,13 @@ edit-kbd-macro
       (let* ((oldbuf (current-buffer))
 	     (mmac (edmacro-fix-menu-commands mac))
 	     (fmt (edmacro-format-keys mmac 1))
-	     (fmtv (edmacro-format-keys mmac (not prefix)))
+	     (fmtv (let ((fmtv (edmacro-format-keys mmac (not prefix))))
+                     (if (not edmacro-reverse-key-order)
+                         fmtv
+                       (with-temp-buffer
+                         (insert fmtv)
+                         (reverse-region (point-min) (point-max))
+                         (buffer-string)))))
 	     (buf (get-buffer-create "*Edit Macro*")))
 	(message "Formatting keyboard macro...done")
 	(switch-to-buffer buf)
@@ -181,6 +200,9 @@ edit-kbd-macro
         (setq-local font-lock-defaults
                     '(edmacro-mode-font-lock-keywords nil nil ((?\" . "w"))))
         (setq font-lock-multiline nil)
+        ;; Make buffer-local so that the commands still work
+        ;; even if the default value changes.
+        (make-local-variable 'edmacro-reverse-key-order)
 	(erase-buffer)
         (insert (substitute-command-keys
                  (concat
@@ -202,7 +224,9 @@ edit-kbd-macro
 	      (insert "Key: none\n")))
 	  (when (and mac-counter mac-format)
 	    (insert (format "Counter: %d\nFormat: \"%s\"\n" mac-counter mac-format))))
-	(insert "\nMacro:\n\n")
+	(insert (format "\nMacro%s:\n\n" (if edmacro-reverse-key-order
+                                             " (most recent line first)"
+                                           "")))
 	(save-excursion
 	  (insert fmtv "\n"))
 	(recenter '(4))
@@ -255,6 +279,33 @@ format-kbd-macro
 \f
 ;;; Commands for *Edit Macro* buffer.
 
+(defvar edmacro--skip-line-regexp
+  "[ \t]*\\($\\|;;\\|REM[ \t\n]\\)"
+  "A regexp identifying lines that should be ignored.")
+
+(defvar edmacro--command-line-regexp
+  "Command:[ \t]*\\([^ \t\n]*\\)[ \t]*$"
+  "A regexp identifying the line containing the command name.")
+
+(defvar edmacro--key-line-regexp
+  "Key:\\(.*\\)$"
+  "A regexp identifying the line containing the bound key sequence.")
+
+(defvar edmacro--counter-line-regexp
+  "Counter:[ \t]*\\([^ \t\n]*\\)[ \t]*$"
+  "A regexp identifying the line containing the counter value.")
+
+(defvar edmacro--format-line-regexp
+  "Format:[ \t]*\"\\([^\n]*\\)\"[ \t]*$"
+  "A regexp identifying the line containing the counter format.")
+
+(defvar edmacro--macro-lines-regexp
+  (rx "Macro"
+      (zero-or-one " (most recent line first)")
+      ":"
+      (zero-or-more (any " \t\n")))
+  "A regexp identifying the lines that precede the macro's contents.")
+
 (defun edmacro-finish-edit ()
   (interactive nil edmacro-mode)
   (unless (eq major-mode 'edmacro-mode)
@@ -266,9 +317,9 @@ edmacro-finish-edit
 	(top (point-min)))
     (goto-char top)
     (let ((case-fold-search nil))
-      (while (cond ((looking-at "[ \t]*\\($\\|;;\\|REM[ \t\n]\\)")
+      (while (cond ((looking-at edmacro--skip-line-regexp)
 		    t)
-		   ((looking-at "Command:[ \t]*\\([^ \t\n]*\\)[ \t]*$")
+		   ((looking-at edmacro--command-line-regexp)
 		    (when edmacro-store-hook
 		      (error "\"Command\" line not allowed in this context"))
 		    (let ((str (match-string 1)))
@@ -283,7 +334,7 @@ edmacro-finish-edit
                                     cmd)))
 			     (keyboard-quit))))
 		    t)
-		   ((looking-at "Key:\\(.*\\)$")
+		   ((looking-at edmacro--key-line-regexp)
 		    (when edmacro-store-hook
 		      (error "\"Key\" line not allowed in this context"))
 		    (let ((key (kbd (match-string 1))))
@@ -303,21 +354,21 @@ edmacro-finish-edit
                                         (edmacro-format-keys key 1))))
 				 (keyboard-quit))))))
 		    t)
-		   ((looking-at "Counter:[ \t]*\\([^ \t\n]*\\)[ \t]*$")
+		   ((looking-at edmacro--counter-line-regexp)
 		    (when edmacro-store-hook
 		      (error "\"Counter\" line not allowed in this context"))
 		    (let ((str (match-string 1)))
 		      (unless (equal str "")
 			(setq mac-counter (string-to-number str))))
 		    t)
-		   ((looking-at "Format:[ \t]*\"\\([^\n]*\\)\"[ \t]*$")
+		   ((looking-at edmacro--format-line-regexp)
 		    (when edmacro-store-hook
 		      (error "\"Format\" line not allowed in this context"))
 		    (let ((str (match-string 1)))
 		      (unless (equal str "")
 			(setq mac-format str)))
 		    t)
-		   ((looking-at "Macro:[ \t\n]*")
+		   ((looking-at edmacro--macro-lines-regexp)
 		    (goto-char (match-end 0))
 		    nil)
 		   ((eobp) nil)
@@ -336,7 +387,13 @@ edmacro-finish-edit
 	(when (buffer-name obuf)
 	  (set-buffer obuf))
 	(message "Compiling keyboard macro...")
-	(let ((mac (edmacro-parse-keys str)))
+	(let ((mac (edmacro-parse-keys (if edmacro-reverse-key-order
+                                           (with-temp-buffer
+                                             (insert str)
+                                             (reverse-region (point-min)
+                                                             (point-max))
+                                             (buffer-string))
+                                         str))))
 	  (message "Compiling keyboard macro...done")
 	  (if store-hook
 	      (funcall store-hook mac)
@@ -372,6 +429,36 @@ edmacro-insert-key
       (insert (edmacro-format-keys key t) "\n")
     (insert (edmacro-format-keys key) " ")))
 
+(defun edmacro-set-macro-to-region-lines (beg end)
+  "Set the macro text to the lines overlapping the buffer text from BEG to END.
+
+When called interactively, this command uses the beginning and
+end of the selected region as the buffer positions.
+
+If the region ends at the beginning of a line, that final line is
+excluded."
+  (interactive "r" edmacro-mode)
+  ;; Use `save-excursion' to restore region if there are any errors.
+  ;; If there are no errors, update the macro contents, then go to the
+  ;; beginning of the macro contents.
+  (let ((final-position))
+    (save-excursion
+      (goto-char beg)
+      (unless (bolp) (setq beg (pos-bol)))
+      (goto-char end)
+      (unless (or (bolp) (eolp)) (setq end (pos-eol)))
+      (let ((text (buffer-substring beg end)))
+        (goto-char (point-min))
+        (if (not (let ((case-fold-search nil))
+                   (re-search-forward edmacro--macro-lines-regexp nil t)))
+            (user-error "\"Macro:\" line not found")
+          (delete-region (match-end 0)
+                         (point-max))
+          (goto-char (point-max))
+          (insert text)
+          (setq final-position (match-beginning 0)))))
+    (goto-char final-position)))
+
 (defun edmacro-mode ()
   "\\<edmacro-mode-map>Keyboard Macro Editing mode.  Press \
 \\[edmacro-finish-edit] to save and exit.
@@ -393,6 +480,10 @@ edmacro-mode
 You can edit these lines to change the places where the new macro
 is stored.
 
+Press \\[edmacro-set-macro-to-region-lines] to replace the text following the \"Macro:\" line
+with the text of the lines overlapping the region of text between
+point and mark.  If that region ends at the beginning of a line,
+that final line is excluded.
 
 Format of keyboard macros during editing:
 
-- 
2.34.1