superword-mode (was: [Emacs-diffs] /srv/bzr/emacs/trunk r112104: * progmodes/cfengine.el (cfengine-common-syntax): Add "_" to word syntax.)

[Ted Zlatanov]

On Tue, 26 Mar 2013 13:06:48 -0400 Stefan Monnier <address@hidden> wrote: 

>> The below simply adds a buffer-local `subword-superiority' defcustom
>> which, when set, makes `subword-mode' treat symbol_words as a single
>> word.  I named it to reflect the opposite behavior (the opposite of
>> "sub" is usually "super", e.g. subscript vs. superscript).  Let me know
>> what you think and if you'd rather see a separate mode or even a
>> separate file instead.  IMO it's such a simple change that I'd rather
>> not make it a big deal.

SM> Using the same file sounds good (if we can come up with a good
SM> encompassing name, we could rename it, but for now it can stay as it is).

SM> So it mostly looks OK, except that rather than a defcustom, I'd prefer
SM> to have a new superword-mode minor mode (and global-superword-mode,
SM> which you already added).

OK; see attached.  Implemented by looking at the `superword-mode'
variable in the internal `subword-mode' commands.

Note new lighter for `subword-mode' as well.  I tried to make the two
modes mutually exclusive but perhaps there's a better way than
explicitly doing it?

Right now, if I do

M-x subword-mode
M-x superword-mode

It correctly turns off `subword-mode' but does not turn `superword-mode'
on.  I have to do `M-x superword-mode' again to enable
`superword-mode'.  I'm not sure how the minor modes interact and didn't
want to spend too much time on the mutual exclusivity.

>> The only possible enhancement I'd want over the attached is to also make
>> `subword-mode' override the CUA keyboard shortcuts (C-left, C-right),
>> but I wasn't sure if that's OK in general.

SM> Yes, that'd be good.

Included and done for both `subword-mode' and `superword-mode'.

Ted

=== modified file 'lisp/progmodes/subword.el'
--- lisp/progmodes/subword.el   2013-01-01 09:11:05 +0000
+++ lisp/progmodes/subword.el   2013-03-26 18:57:53 +0000
@@ -26,7 +26,8 @@
 
 ;; This package provides `subword' oriented commands and a minor mode
 ;; (`subword-mode') that substitutes the common word handling
-;; functions with them.
+;; functions with them.  It also provides the `superword-mode' minor
+;; mode that treats symbols as words, the opposite of `subword-mode'.
 
 ;; In spite of GNU Coding Standards, it is popular to name a symbol by
 ;; mixing uppercase and lowercase letters, e.g. "GtkWidget",
@@ -43,12 +44,13 @@
 
 ;; The subword oriented commands defined in this package recognize
 ;; subwords in a nomenclature to move between them and to edit them as
-;; words.
+;; words.  You also get a mode to treat symbols as words instead,
+;; called `superword-mode' (the opposite of `subword-mode').
 
 ;; In the minor mode, all common key bindings for word oriented
 ;; commands are overridden by the subword oriented commands:
 
-;; Key     Word oriented command      Subword oriented command
+;; Key     Word oriented command      Subword oriented command (also superword)
 ;; ============================================================
 ;; M-f     `forward-word'             `subword-forward'
 ;; M-b     `backward-word'            `subword-backward'
@@ -71,6 +73,13 @@
 ;;       (lambda () (subword-mode 1)))
 ;;
 
+;; To make the mode turn `superword-mode' on automatically for
+;; only some modes, put the following code in your .emacs:
+;;
+;; (add-hook 'c-mode-common-hook
+;;       (lambda () (superword-mode 1)))
+;;
+
 ;; Acknowledgment:
 ;; The regular expressions to detect subwords are mostly based on
 ;; the old `c-forward-into-nomenclature' originally contributed by
@@ -98,7 +107,8 @@
   (let ((map (make-sparse-keymap)))
     (dolist (cmd '(forward-word backward-word mark-word kill-word
                                backward-kill-word transpose-words
-                                capitalize-word upcase-word downcase-word))
+                                capitalize-word upcase-word downcase-word
+                                left-word right-word))
       (let ((othercmd (let ((name (symbol-name cmd)))
                         (string-match "\\([[:alpha:]-]+\\)-word[s]?" name)
                         (intern (concat "subword-" (match-string 1 name))))))
@@ -133,9 +143,11 @@
 as words.
 
 \\{subword-mode-map}"
-    nil
-    nil
-    subword-mode-map)
+    :lighter " ,"
+    nil
+    nil
+    subword-mode-map
+    (when superword-mode (superword-mode -1)))
 
 (define-obsolete-function-alias 'c-subword-mode 'subword-mode "23.2")
 
@@ -161,6 +173,10 @@
 
 (put 'subword-forward 'CUA 'move)
 
+(defun subword-right (&optional arg)
+  (interactive "p")
+  (subword-forward arg))
+
 (defun subword-backward (&optional arg)
   "Do the same as `backward-word' but on subwords.
 See the command `subword-mode' for a description of subwords.
@@ -168,6 +184,10 @@
   (interactive "p")
   (subword-forward (- (or arg 1))))
 
+(defun subword-left (&optional arg)
+  (interactive "p")
+  (subword-backward arg))
+
 (defun subword-mark (arg)
   "Do the same as `mark-word' but on subwords.
 See the command `subword-mode' for a description of subwords.
@@ -254,41 +274,86 @@
     (unless advance
       (goto-char start))))
 
+
+
+(defvar superword-mode-map
+  (let ((map (make-sparse-keymap)))
+    (dolist (cmd '(forward-word backward-word mark-word kill-word
+                               backward-kill-word transpose-words
+                                capitalize-word upcase-word downcase-word
+                                left-word right-word))
+      (let ((othercmd (let ((name (symbol-name cmd)))
+                        (string-match "\\([[:alpha:]-]+\\)-word[s]?" name)
+                        (intern (concat "subword-" (match-string 1 name))))))
+        (define-key map (vector 'remap cmd) othercmd)))
+    map)
+  "Keymap used in `superword-mode' minor mode.")
+
+;;;###autoload
+(define-minor-mode superword-mode
+  "Toggle superword movement and editing (Superword mode).
+With a prefix argument ARG, enable Superword mode if ARG is
+positive, and disable it otherwise.  If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Superword mode is a buffer-local minor mode.  Enabling it remaps
+word-based editing commands to superword-based commands that
+treat symbols as words, e.g. \"this_is_a_symbol\".
+
+The superword oriented commands activated in this minor mode
+recognize symbols as superwords to move between superwords and to
+edit them as words.
+
+\\{superword-mode-map}"
+    :lighter " ¹"
+    nil
+    nil
+    superword-mode-map
+    (when subword-mode (subword-mode -1)))
+
+;;;###autoload
+(define-global-minor-mode global-superword-mode superword-mode
+  (lambda () (superword-mode 1)))
 
 
 ;;
 ;; Internal functions
 ;;
 (defun subword-forward-internal ()
-  (if (and
-       (save-excursion
-        (let ((case-fold-search nil))
-          (re-search-forward subword-forward-regexp nil t)))
-       (> (match-end 0) (point)))
-      (goto-char
-       (cond
-       ((< 1 (- (match-end 2) (match-beginning 2)))
-        (1- (match-end 2)))
-       (t
-        (match-end 0))))
-    (forward-word 1)))
-
+  (if superword-mode
+      (forward-symbol 1)
+    (if (and
+         (save-excursion
+           (let ((case-fold-search nil))
+             (re-search-forward subword-forward-regexp nil t)))
+         (> (match-end 0) (point)))
+        (goto-char
+         (cond
+          ((< 1 (- (match-end 2) (match-beginning 2)))
+           (1- (match-end 2)))
+          (t
+           (match-end 0))))
+      (forward-word 1))))
 
 (defun subword-backward-internal ()
-  (if (save-excursion
-       (let ((case-fold-search nil))
-         (re-search-backward subword-backward-regexp nil t)))
-      (goto-char
-       (cond
-       ((and (match-end 3)
-             (< 1 (- (match-end 3) (match-beginning 3)))
-             (not (eq (point) (match-end 3))))
-        (1- (match-end 3)))
-       (t
-        (1+ (match-beginning 0)))))
-    (backward-word 1)))
+  (if superword-mode
+      (forward-symbol -1)
+    (if (save-excursion
+          (let ((case-fold-search nil))
+            (re-search-backward subword-backward-regexp nil t)))
+        (goto-char
+         (cond
+          ((and (match-end 3)
+                (< 1 (- (match-end 3) (match-beginning 3)))
+                (not (eq (point) (match-end 3))))
+           (1- (match-end 3)))
+          (t
+           (1+ (match-beginning 0)))))
+      (backward-word 1))))
 
 
+
 (provide 'subword)
+(provide 'superword)
 
 ;;; subword.el ends here