refactor(custom-text-enclose): extract the region-or-word dispatch

cj/surround/wrap/unwrap-word-or-region each repeated the same skeleton: target the active region, else the word at point, else show a message; then delete and re-insert the transformed text. Extract cj/--enclose-region-or-word, which takes the transform as a function and the no-target message, so each command reads its prompts then delegates. Behavior and messages unchanged; adds direct coverage of the dispatch helper.

2 files changed, 92 insertions, 48 deletions

diff --git a/modules/custom-text-enclose.el b/modules/custom-text-enclose.el
index fdfb92230..5b1b00a71 100644
--- a/modules/custom-text-enclose.el
+++ b/modules/custom-text-enclose.el
@@ -54,48 +54,42 @@ CLOSING is appended to TEXT.
 Returns the wrapped text without modifying the buffer."
   (concat opening text closing))
 
+(defun cj/--enclose-region-or-word (transform &optional no-target-message)
+  "Apply TRANSFORM to the active region or the word at point, in place.
+TRANSFORM is a function of one string (the target text) returning the
+replacement text.  An active region is the target; otherwise the word at
+point is.  With neither, show NO-TARGET-MESSAGE (or a default) and leave the
+buffer unchanged.  Point is left after the inserted text."
+  (let ((bounds (cond ((use-region-p) (cons (region-beginning) (region-end)))
+                      ((thing-at-point 'word) (bounds-of-thing-at-point 'word)))))
+    (if (null bounds)
+        (message "%s" (or no-target-message
+                          "Can't do that. No word at point and no region selected."))
+      (let* ((beg (car bounds))
+             (end (cdr bounds))
+             (text (buffer-substring beg end)))
+        (delete-region beg end)
+        (goto-char beg)
+        (insert (funcall transform text))))))
+
 (defun cj/surround-word-or-region ()
   "Surround the word at point or active region with a string.
 The surround string is read from the minibuffer."
   (interactive)
-  (let ((str (read-string "Surround with: "))
-        (regionp (use-region-p)))
-    (if regionp
-        (let ((beg (region-beginning))
-              (end (region-end))
-              (text (buffer-substring (region-beginning) (region-end))))
-          (delete-region beg end)
-          (goto-char beg)
-          (insert (cj/--surround text str)))
-      (if (thing-at-point 'word)
-          (let* ((bounds (bounds-of-thing-at-point 'word))
-                 (text (buffer-substring (car bounds) (cdr bounds))))
-            (delete-region (car bounds) (cdr bounds))
-            (goto-char (car bounds))
-            (insert (cj/--surround text str)))
-        (message "Can't insert around. No word at point and no region selected.")))))
+  (let ((str (read-string "Surround with: ")))
+    (cj/--enclose-region-or-word
+     (lambda (text) (cj/--surround text str))
+     "Can't insert around. No word at point and no region selected.")))
 
 (defun cj/wrap-word-or-region ()
   "Wrap the word at point or active region with different opening/closing strings.
 The opening and closing strings are read from the minibuffer."
   (interactive)
   (let ((opening (read-string "Opening: "))
-        (closing (read-string "Closing: "))
-        (regionp (use-region-p)))
-    (if regionp
-        (let ((beg (region-beginning))
-              (end (region-end))
-              (text (buffer-substring (region-beginning) (region-end))))
-          (delete-region beg end)
-          (goto-char beg)
-          (insert (cj/--wrap text opening closing)))
-      (if (thing-at-point 'word)
-          (let* ((bounds (bounds-of-thing-at-point 'word))
-                 (text (buffer-substring (car bounds) (cdr bounds))))
-            (delete-region (car bounds) (cdr bounds))
-            (goto-char (car bounds))
-            (insert (cj/--wrap text opening closing)))
-        (message "Can't wrap. No word at point and no region selected.")))))
+        (closing (read-string "Closing: ")))
+    (cj/--enclose-region-or-word
+     (lambda (text) (cj/--wrap text opening closing))
+     "Can't wrap. No word at point and no region selected.")))
 
 (defun cj/--unwrap (text opening closing)
   "Internal implementation: Remove OPENING and CLOSING from TEXT if present.
@@ -114,22 +108,10 @@ Returns the unwrapped text if both delimiters present, otherwise unchanged."
 The opening and closing strings are read from the minibuffer."
   (interactive)
   (let ((opening (read-string "Opening to remove: "))
-        (closing (read-string "Closing to remove: "))
-        (regionp (use-region-p)))
-    (if regionp
-        (let ((beg (region-beginning))
-              (end (region-end))
-              (text (buffer-substring (region-beginning) (region-end))))
-          (delete-region beg end)
-          (goto-char beg)
-          (insert (cj/--unwrap text opening closing)))
-      (if (thing-at-point 'word)
-          (let* ((bounds (bounds-of-thing-at-point 'word))
-                 (text (buffer-substring (car bounds) (cdr bounds))))
-            (delete-region (car bounds) (cdr bounds))
-            (goto-char (car bounds))
-            (insert (cj/--unwrap text opening closing)))
-        (message "Can't unwrap. No word at point and no region selected.")))))
+        (closing (read-string "Closing to remove: ")))
+    (cj/--enclose-region-or-word
+     (lambda (text) (cj/--unwrap text opening closing))
+     "Can't unwrap. No word at point and no region selected.")))
 
 (defun cj/--append-to-lines (text suffix)
   "Internal implementation: Append SUFFIX to each line in TEXT.
diff --git a/tests/test-custom-text-enclose--enclose-region-or-word.el b/tests/test-custom-text-enclose--enclose-region-or-word.el
new file mode 100644
index 000000000..4075fb050
--- /dev/null
+++ b/tests/test-custom-text-enclose--enclose-region-or-word.el
@@ -0,0 +1,62 @@
+;;; test-custom-text-enclose--enclose-region-or-word.el --- Tests for the shared enclose dispatch -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; cj/--enclose-region-or-word is the dispatch+edit skeleton extracted from
+;; cj/surround/wrap/unwrap-word-or-region (region target, else word at point,
+;; else a no-target message).  The three commands stay covered by
+;; test-custom-text-enclose-public-wrappers.el; these cover the helper directly,
+;; including the custom and default no-target messages.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'custom-text-enclose)
+
+(ert-deftest test-cte-enclose-region-target ()
+  "Normal: an active region is the target; TRANSFORM is applied to it."
+  (with-temp-buffer
+    (let ((transient-mark-mode t))
+      (insert "abc")
+      (goto-char (point-min))
+      (push-mark (point) t t)
+      (goto-char (point-max))
+      (cj/--enclose-region-or-word #'upcase))
+    (should (equal (buffer-string) "ABC"))
+    (should (= (point) 4))))            ; after the inserted "ABC" (start 1 + 3)
+
+(ert-deftest test-cte-enclose-word-at-point-target ()
+  "Normal: with no region, the word at point is the target."
+  (with-temp-buffer
+    (insert "foo bar")
+    (goto-char (point-min))            ; point on "foo"
+    (cj/--enclose-region-or-word (lambda (s) (concat "<" s ">")))
+    (should (equal (buffer-string) "<foo> bar"))))
+
+(ert-deftest test-cte-enclose-no-target-default-message ()
+  "Boundary: no region and no word => default message, buffer untouched."
+  (with-temp-buffer
+    (insert "   ")                     ; whitespace, no word
+    (goto-char (point-min))
+    (let ((msg nil))
+      (cl-letf (((symbol-function 'message)
+                 (lambda (fmt &rest args) (setq msg (apply #'format fmt args)))))
+        (cj/--enclose-region-or-word #'upcase))
+      (should (string-match-p "No word at point" msg))
+      (should (equal (buffer-string) "   ")))))
+
+(ert-deftest test-cte-enclose-no-target-custom-message ()
+  "Boundary: a supplied NO-TARGET-MESSAGE overrides the default."
+  (with-temp-buffer
+    (insert "   ")
+    (goto-char (point-min))
+    (let ((msg nil))
+      (cl-letf (((symbol-function 'message)
+                 (lambda (fmt &rest args) (setq msg (apply #'format fmt args)))))
+        (cj/--enclose-region-or-word #'upcase "custom no-target text"))
+      (should (equal msg "custom no-target text")))))
+
+(provide 'test-custom-text-enclose--enclose-region-or-word)
+;;; test-custom-text-enclose--enclose-region-or-word.el ends here