1.1.5

Fix mc/dump-list (take 2): it looses old setting

.travis.yml

@@ -1,12 +1,20 @@
 language: emacs-lisp
 before_install:
-  - if [ "$ECUKES_EMACS" = 'emacs-snapshot' ]; then
+  - if [ "$EMACS" = 'emacs-snapshot' ]; then
       sudo add-apt-repository -y ppa:cassou/emacs &&
       sudo apt-get update -qq &&
       sudo apt-get install -qq
           emacs-snapshot-el emacs-snapshot-gtk emacs-snapshot;
     fi
+  - if [ "$EMACS" = 'emacs24' ]; then
+      sudo add-apt-repository -y ppa:cassou/emacs &&
+      sudo apt-get update -qq &&
+      sudo apt-get install -qq
+          emacs24 emacs24-el emacs24-common-non-dfsg;
+    fi
 env:
-  - ECUKES_EMACS=emacs
+  - EMACS=emacs
+  - EMACS=emacs24
+  - EMACS=emacs-snapshot
 script:
   ./run-travis-ci.sh

README.md

@@ -35,43 +35,56 @@ insert a newline in multiple-cursors-mode, use `C-j`.
 
 You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.com/e13.html).
 
-## More commands to play around with
+## Command overview
 
-I've set up my key-bindings like so:
+### Mark one more occurrence
 
-    ;; From active region to multiple cursors:
-    (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
-    (global-set-key (kbd "C-S-c C-e") 'mc/edit-ends-of-lines)
-    (global-set-key (kbd "C-S-c C-a") 'mc/edit-beginnings-of-lines)
+ - `mc/mark-next-like-this`: Adds a cursor and region at the next part of the buffer forwards that matches the current region.
+ - `mc/mark-next-word-like-this`: Like `mc/mark-next-like-this` but only for whole words.
+ - `mc/mark-next-symbol-like-this`: Like `mc/mark-next-like-this` but only for whole symbols.
+ - `mc/mark-previous-like-this`: Adds a cursor and region at the next part of the buffer backwards that matches the current region.
+ - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
+ - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
+ - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
 
-When you have an active region that spans multiple lines, the preceeding three
-commands will add one cursor to each line.
+### Mark many occurrences
 
-    ;; Rectangular region mode
-    (global-set-key (kbd "H-SPC") 'set-rectangular-region-anchor)
+ - `mc/mark-all-like-this`: Marks all parts of the buffer that matches the current region.
+ - `mc/mark-all-words-like-this`: Like `mc/mark-all-like-this` but only for whole words.
+ - `mc/mark-all-symbols-like-this`: Like `mc/mark-all-like-this` but only for whole symbols.
+ - `mc/mark-all-in-region`: Prompts for a string to match in the region, adding cursors to all of them.
+ - `mc/mark-all-like-this-in-defun`: Marks all parts of the current defun that matches the current region.
+ - `mc/mark-all-words-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole words.
+ - `mc/mark-all-symbols-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole symbols.
+ - `mc/mark-all-like-this-dwim`: Tries to be smart about marking everything you want. Can be pressed multiple times.
 
-Think of this one as `set-mark` except you're marking a rectangular region. It is
-an exceedingly quick way of adding multiple cursors to multiple lines.
+### Special
 
-    ;; Mark more like this
-    (global-set-key (kbd "M-æ") 'mc/mark-all-like-this)
-    (global-set-key (kbd "C-å") 'mc/mark-previous-like-this)
-    (global-set-key (kbd "C-æ") 'mc/mark-next-like-this)
-    (global-set-key (kbd "C-Æ") 'mc/mark-more-like-this-extended)
-    (global-set-key (kbd "M-å") 'mc/mark-all-in-region)
+ - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
+ - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
 
-Okay, yes, I have a crazy norwegian keyboard. Regardless, these will look at
-whatever you've got selected at the moment, and mark more places like that in
-the buffer.
+## Tips and tricks
+
+- To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
+  first disable multiple regions before disabling multiple cursors. If you want to
+  insert a newline in multiple-cursors-mode, use `C-j`.
+
+- Sometimes you end up with cursors outside of your view. You can
+  scroll the screen to center on each cursor with `C-v` and `M-v`.
+
+- Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
+  on the next line.
+
+- Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
+
+- Notice that the number of cursors active can be seen in the modeline.
+
+- If you would like to keep the global bindings clean, and get custom keybindings
+  when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).
 
 BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
 right next to the key for `er/expand-region`.
 
-## Scrolling
-
-Sometimes you end up with cursors outside of your view. You can scroll the
-screen to center on each cursor with `C-v` and `M-v`.
-
 ## Unknown commands
 
 Multiple-cursors uses two lists of commands to know what to do: the run-once list
@@ -113,6 +126,14 @@ Run the tests with:
 
     $ ./util/ecukes/ecukes --graphical
 
+## Contributors
+
+* [Takafumi Arakaki](https://github.com/tkf) made .mc-lists.el diff friendly
+* [Marco Baringer](https://github.com/segv) contributed looping to mc/cycle and adding cursors without region for mark-more.
+* [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line
+* [Fuco](https://github.com/Fuco1) added the first version of `mc/mark-all-like-this-dwim`
+
+Thanks!
 
 ## License
 

features/mark-all-dwim-html.feature

@@ -0,0 +1,94 @@
+Feature: Mark all do-what-I-mean (html)
+
+  Background:
+    Given I turn on html-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    <body>
+      <div class="abc"> def </div>
+      <div class="ghi"> jkl </div>
+    </body>
+    """
+
+  Scenario: Marks tags in html-mode, from front
+    When I go to the front of the word "abc"
+    And I press "M-b"
+    And I press "M-b"
+    And I press "M-$"
+    And I type "h1"
+    Then I should see:
+    """
+    <body>
+      <h1 class="abc"> def </h1>
+      <div class="ghi"> jkl </div>
+    </body>
+    """
+
+  Scenario: Marks tags in html-mode, from back
+    When I go to the end of the word "jkl"
+    And I press "M-f"
+    And I press "M-$"
+    And I type "h1"
+    Then I should see:
+    """
+    <body>
+      <div class="abc"> def </div>
+      <h1 class="ghi"> jkl </h1>
+    </body>
+    """
+
+  Scenario: Marks tags in html-mode, from outside front
+    When I go to the front of the word "abc"
+    And I press "M-b"
+    And I press "M-b"
+    And I press "C-b"
+    And I press "M-$"
+    And I type "h1"
+    Then I should see:
+    """
+    <body>
+      <h1 class="abc"> def </h1>
+      <div class="ghi"> jkl </div>
+    </body>
+    """
+
+  Scenario: Marks tags in html-mode, from outside back
+    When I go to the end of the word "jkl"
+    And I press "M-f"
+    And I press "C-f"
+    And I press "M-$"
+    And I type "h1"
+    Then I should see:
+    """
+    <body>
+      <div class="abc"> def </div>
+      <h1 class="ghi"> jkl </h1>
+    </body>
+    """
+
+  Scenario: Marks words in html-mode
+    When I go to the front of the word "abc"
+    And I press "M-$"
+    And I type "def"
+    Then I should see:
+    """
+    <body>
+      <div class="def"> def </div>
+      <div class="ghi"> jkl </div>
+    </body>
+    """
+
+  Scenario: Marks words in html-mode
+    When I go to the front of the word "abc"
+    And I press "M-$"
+    And I type "def"
+    And I press "M-$"
+    And I type "hah"
+    Then I should see:
+    """
+    <body>
+      <div class="hah"> hah </div>
+      <div class="ghi"> jkl </div>
+    </body>
+    """

features/mark-all-dwim.feature

@@ -0,0 +1,38 @@
+Feature: Mark all do-what-I-mean
+
+  Scenario: Mark symbols in defun
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I go to the end of the word "abc"
+    And I press "M-f"
+    And I press "M-$"
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (ghi) (message some-other-ghi))
+    """
+
+  Scenario: Mark all symbols by pressing twice
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message ghi))
+    """
+    When I go to the end of the word "abc"
+    And I press "M-f"
+    And I press "M-$"
+    And I press "M-$"
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message hmm))
+    """

features/mark-more.feature

@@ -94,3 +94,41 @@ Feature: Marking multiple parts of the buffer
     And I type "more"
     Then I should have 2 cursors
     And I should see "Here's more, more and text"
+
+  Scenario: Marking without an active region
+    When I insert:
+    """
+    aaa
+    bbb
+    ccc
+    """
+    And I go to the front of the word "bbb"
+    And I press "C->"
+    And I type "_"
+    Then I should have 2 cursors
+    And I should see:
+    """
+    aaa
+    _bbb
+    _ccc
+    """
+
+  Scenario: Increasing number of cursors without an active region
+    When I insert:
+    """
+    aaa
+    bbb
+    ccc
+    """
+    And I go to the front of the word "bbb"
+    And I press "C->"
+    And I press "C-<"
+    And i press "C-f"
+    And I type "_"
+    Then I should have 3 cursors
+    And I should see:
+    """
+    a_aa
+    b_bb
+    c_cc
+    """

features/multiple-cursors-core.feature

@@ -119,6 +119,16 @@ Feature: Multiple cursors core
     And I type "!"
     Then I should see "This ! contains the word ! twice"
 
+  Scenario: wrap-region (function turns to keyboard macros)
+    Given I turn on wrap-region-mode
+    And I insert "This text contains the word text twice"
+    And I go to the front of the word "text"
+    And I press "C-M-SPC"
+    And I press "C->"
+    And I press "C-g"
+    And I type "("
+    Then I should see "This (text contains the word (text twice"
+
   Scenario: Bound keyboard macros
     Given I have bound C-! to a keyboard macro that insert "_"
     And I have cursors at "text" in "This text contains the word text twice"
@@ -148,3 +158,17 @@ Feature: Multiple cursors core
     contains
     twice
     """
+
+  Scenario: Looping forwards around cursors
+    Given I have cursors at "_" in "1_34567_9"
+    And I press "C-v"
+    And I press "C-v"
+    And I press "C-v"
+    Then the cursor should be at point "8"
+
+  Scenario: Looping backwards around cursors
+    Given I have cursors at "_" in "1_34567_9"
+    And I press "M-v"
+    And I press "M-v"
+    Then the cursor should be at point "2"
+

features/support/env.el

@@ -7,10 +7,12 @@
 (add-to-list 'load-path multiple-cursors-root-path)
 (add-to-list 'load-path multiple-cursors-util-path)
 (add-to-list 'load-path (expand-file-name "espuds" multiple-cursors-util-path))
+(add-to-list 'load-path (expand-file-name "vendor" multiple-cursors-util-path))
 
 (require 'multiple-cursors)
 (require 'espuds)
 (require 'ert)
+(require 'wrap-region)
 
 (defun mc/save-lists ()) ;; redefine to do nothing when running tests
 
@@ -21,6 +23,7 @@
  (global-set-key (kbd "C->") 'mc/mark-next-like-this)
  (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
  (global-set-key (kbd "M-!") 'mc/mark-all-like-this)
+ (global-set-key (kbd "M-$") 'mc/mark-all-like-this-dwim)
  (global-set-key (kbd "M-#") 'mc/mark-all-in-region)
  (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
  (global-set-key (kbd "H-SPC") 'set-rectangular-region-anchor)
@@ -31,6 +34,7 @@
  (cua-mode 0)
  (delete-selection-mode 0)
  (subword-mode 0)
+ (wrap-region-mode 0)
  (setq set-mark-default-inactive nil)
  (deactivate-mark))
 

mc-cycle-cursors.el

@@ -30,7 +30,7 @@
 
 (eval-when-compile (require 'cl))
 
-(defun mc/next-cursor-after-point ()
+(defun mc/next-fake-cursor-after-point ()
   (let ((pos (point))
         (next-pos (point-max))
         next)
@@ -42,7 +42,7 @@
          (setq next cursor))))
     next))
 
-(defun mc/prev-cursor-before-point ()
+(defun mc/prev-fake-cursor-before-point ()
   (let ((pos (point))
         (prev-pos (point-min))
         prev)
@@ -54,27 +54,69 @@
          (setq prev cursor))))
     prev))
 
+(defcustom mc/cycle-looping-behaviour 'continue
+  "What to do if asked to cycle beyond the last cursor or before the first cursor."
+  :type '(radio (const :tag "Loop around to beginning/end of document." continue)
+                (const :tag "Warn and then loop around." warn)
+                (const :tag "Signal an error." error)
+                (const :tag "Don't loop." stop))
+  :group 'multiple-cursors)
+
+(defun mc/handle-loop-condition (error-message)
+  (ecase mc/cycle-looping-behaviour
+    (error (error error-message))
+    (warn  (message error-message))
+    (continue 'continue)
+    (stop 'stop)))
+
+(defun mc/first-fake-cursor-after (point)
+  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
+  (let* ((cursors (mc/all-fake-cursors))
+         (cursors-after-point (remove-if (lambda (cursor)
+                                           (< (mc/cursor-beg cursor) point))
+                                         cursors))
+         (cursors-in-order (sort* cursors-after-point '< :key 'mc/cursor-beg)))
+    (first cursors-in-order)))
+
+(defun mc/last-fake-cursor-before (point)
+  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
+  (let* ((cursors (mc/all-fake-cursors))
+         (cursors-before-point (remove-if (lambda (cursor)
+                                            (> (mc/cursor-end cursor) point))
+                                          cursors))
+         (cursors-in-order (sort* cursors-before-point '> :key 'mc/cursor-end)))
+    (first cursors-in-order)))
+
+(defun* mc/cycle (next-cursor fallback-cursor loop-message)
+  (when (null next-cursor)
+    (when (eql 'stop (mc/handle-loop-condition loop-message))
+      (return-from mc/cycle nil))
+    (setf next-cursor fallback-cursor))
+  (mc/create-fake-cursor-at-point)
+  (mc/pop-state-from-overlay next-cursor)
+  (recenter))
+
 (defun mc/cycle-forward ()
   (interactive)
-  (let ((next-cursor (mc/next-cursor-after-point)))
-    (unless next-cursor
-      (error "We're already at the last cursor"))
-    (mc/create-fake-cursor-at-point)
-    (mc/pop-state-from-overlay next-cursor)
-    (recenter)))
+  (mc/cycle (mc/next-fake-cursor-after-point)
+            (mc/first-fake-cursor-after (point-min))
+             "We're already at the last cursor."))
 
 (defun mc/cycle-backward ()
   (interactive)
-  (let ((prev-cursor (mc/prev-cursor-before-point)))
-    (unless prev-cursor
-      (error "We're already at the first cursor"))
-    (mc/create-fake-cursor-at-point)
-    (mc/pop-state-from-overlay prev-cursor)
-    (recenter)))
+  (mc/cycle (mc/prev-fake-cursor-before-point)
+            (mc/last-fake-cursor-before (point-max))
+            "We're already at the last cursor"))
 
 (define-key mc/keymap (kbd "C-v") 'mc/cycle-forward)
 (define-key mc/keymap (kbd "M-v") 'mc/cycle-backward)
 
 (provide 'mc-cycle-cursors)
 
+
+;; Local Variables:
+;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
+;; End:
+
 ;;; mc-cycle-cursors.el ends here

mc-mark-more.el

@@ -28,6 +28,7 @@
 ;;; Code:
 
 (require 'multiple-cursors-core)
+(require 'thingatpt)
 
 (defun mc/cursor-end (cursor)
   (if (overlay-get cursor 'mark-active)
@@ -79,34 +80,69 @@
                             (mc/cursor-end cursor))))
     strings))
 
+(defvar mc/enclose-search-term nil
+  "How should mc/mark-more-* search for more matches?
+
+Match everything: nil
+Match only whole words: 'words
+Match only whole symbols: 'symbols
+
+Use like case-fold-search, don't recommend setting it globally.")
+
+(defun mc/mark-more-like-this (skip-last direction)
+  (let ((case-fold-search nil)
+        (re (regexp-opt (mc/region-strings) mc/enclose-search-term))
+        (point-out-of-order (ecase direction
+                              (forwards       (< (point) (mark)))
+                              (backwards (not (< (point) (mark))))))
+        (furthest-cursor (ecase direction
+                           (forwards  (mc/furthest-cursor-after-point))
+                           (backwards (mc/furthest-cursor-before-point))))
+        (start-char (ecase direction
+                      (forwards  (mc/furthest-region-end))
+                      (backwards (mc/first-region-start))))
+        (search-function (ecase direction
+                           (forwards  'search-forward-regexp)
+                           (backwards 'search-backward-regexp)))
+        (match-point-getter (ecase direction
+                              (forwards 'match-beginning)
+                              (backwards 'match-end))))
+    (mc/save-excursion
+     (goto-char start-char)
+     (when skip-last
+       (mc/remove-fake-cursor furthest-cursor))
+     (if (funcall search-function re nil t)
+         (progn
+           (push-mark (funcall match-point-getter 0))
+           (when point-out-of-order
+             (exchange-point-and-mark))
+           (mc/create-fake-cursor-at-point))
+       (error "no more matches found.")))))
+
 ;;;###autoload
 (defun mc/mark-next-like-this (arg)
   "Find and mark the next part of the buffer matching the currently active region
 With negative ARG, delete the last one instead.
 With zero ARG, skip the last one and mark next."
   (interactive "p")
-  (unless (region-active-p)
-    (error "Mark a region to match first."))
-  (when (< arg 0)
-    (mc/remove-fake-cursor (mc/furthest-cursor-after-point)))
-  (when (>= arg 0)
-    (let ((case-fold-search nil)
-          (point-first (< (point) (mark)))
-          (re (regexp-opt (mc/region-strings)))
-          (furthest-cursor (mc/furthest-cursor-after-point)))
-      (mc/save-excursion
-       (goto-char (mc/furthest-region-end))
-       (when (= arg 0)
-         (mc/remove-fake-cursor furthest-cursor))
-       (if (search-forward-regexp re nil t)
-           (progn
-             (push-mark (match-beginning 0))
-             (when point-first (exchange-point-and-mark))
-             (mc/create-fake-cursor-at-point))
-         (error "no more found forward")))))
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
+  (if (region-active-p)
+      (if (< arg 0)
+          (mc/remove-fake-cursor (mc/furthest-cursor-after-point))
+        (mc/mark-more-like-this (= arg 0) 'forwards))
+    (mc/mark-lines arg 'forwards))
+  (mc/maybe-multiple-cursors-mode))
+
+;;;###autoload
+(defun mc/mark-next-word-like-this (arg)
+  (interactive "p")
+  (let ((mc/enclose-search-term 'words))
+    (mc/mark-next-like-this arg)))
+
+;;;###autoload
+(defun mc/mark-next-symbol-like-this (arg)
+  (interactive "p")
+  (let ((mc/enclose-search-term 'symbols))
+    (mc/mark-next-like-this arg)))
 
 ;;;###autoload
 (defun mc/mark-previous-like-this (arg)
@@ -114,28 +150,57 @@ With zero ARG, skip the last one and mark next."
 With negative ARG, delete the last one instead.
 With zero ARG, skip the last one and mark next."
   (interactive "p")
-  (unless (region-active-p)
-    (error "Mark a region to match first."))
-  (when (< arg 0)
-    (mc/remove-fake-cursor (mc/furthest-cursor-before-point)))
-  (when (>= arg 0)
-    (let ((case-fold-search nil)
-          (point-first (< (point) (mark)))
-          (re (regexp-opt (mc/region-strings)))
-          (furthest-cursor (mc/furthest-cursor-before-point)))
-      (mc/save-excursion
-       (goto-char (mc/first-region-start))
-       (when (= arg 0)
-         (mc/remove-fake-cursor furthest-cursor))
-       (if (search-backward-regexp re nil t)
-           (progn
-             (push-mark (match-end 0))
-             (unless point-first (exchange-point-and-mark))
-             (mc/create-fake-cursor-at-point))
-         (error "no more found backward")))))
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
+  (if (region-active-p)
+      (if (< arg 0)
+          (mc/remove-fake-cursor (mc/furthest-cursor-before-point))
+        (mc/mark-more-like-this (= arg 0) 'backwards))
+    (mc/mark-lines arg 'backwards))
+  (mc/maybe-multiple-cursors-mode))
+
+;;;###autoload
+(defun mc/mark-previous-word-like-this (arg)
+  (interactive "p")
+  (let ((mc/enclose-search-term 'words))
+    (mc/mark-previous-like-this arg)))
+
+;;;###autoload
+(defun mc/mark-previous-symbol-like-this (arg)
+  (interactive "p")
+  (let ((mc/enclose-search-term 'symbols))
+    (mc/mark-previous-like-this arg)))
+
+(defun mc/mark-lines (num-lines direction)
+  (dotimes (i num-lines)
+    (mc/create-fake-cursor-at-point)
+    (ecase direction
+      (forwards (loop do (next-line 1 nil)
+                      while (mc/all-fake-cursors (point) (1+ (point)))))
+      (backwards (loop do (previous-line 1 nil)
+                       while (mc/all-fake-cursors (point) (1+ (point))))))))
+
+;;;###autoload
+(defun mc/mark-next-lines (arg)
+  (interactive "p")
+  (mc/mark-lines arg 'forwards)
+  (mc/maybe-multiple-cursors-mode))
+
+;;;###autoload
+(defun mc/mark-previous-lines (arg)
+  (interactive "p")
+  (mc/mark-lines arg 'backwards)
+  (mc/maybe-multiple-cursors-mode))
+
+;;;###autoload
+(defun mc/unmark-next-like-this (arg)
+  "Deselect next part of the buffer matching the currently active region."
+  (interactive)
+  (mc/mark-next-like-this -1))
+
+;;;###autoload
+(defun mc/unmark-previous-like-this (arg)
+  "Deselect prev part of the buffer matching the currently active region."
+  (interactive)
+  (mc/mark-previous-like-this -1))
 
 ;;;###autoload
 (defun mc/mark-all-like-this ()
@@ -147,7 +212,7 @@ With zero ARG, skip the last one and mark next."
   (let ((master (point))
         (case-fold-search nil)
         (point-first (< (point) (mark)))
-        (re (regexp-opt (mc/region-strings))))
+        (re (regexp-opt (mc/region-strings) mc/enclose-search-term)))
     (mc/save-excursion
      (goto-char 0)
      (while (search-forward-regexp re nil t)
@@ -160,6 +225,18 @@ With zero ARG, skip the last one and mark next."
       (multiple-cursors-mode 1)
     (multiple-cursors-mode 0)))
 
+;;;###autoload
+(defun mc/mark-all-words-like-this ()
+  (interactive)
+  (let ((mc/enclose-search-term 'words))
+    (mc/mark-all-like-this)))
+
+;;;###autoload
+(defun mc/mark-all-symbols-like-this ()
+  (interactive)
+  (let ((mc/enclose-search-term 'symbols))
+    (mc/mark-all-like-this)))
+
 ;;;###autoload
 (defun mc/mark-all-in-region (beg end)
   "Find and mark all the parts in the region matching the given search"
@@ -226,6 +303,128 @@ is one of the above."
         (setq ev (read-event "Use arrow keys for more marks: "))))
     (push ev unread-command-events)))
 
+(defvar mc--restrict-mark-all-to-symbols nil)
+
+;;;###autoload
+(defun mc/mark-all-like-this-dwim (arg)
+  "Tries to guess what you want to mark all of.
+Can be pressed multiple times to increase selection.
+
+With prefix, it behaves the same as original `mc/mark-all-like-this'"
+  (interactive "P")
+  (if arg
+      (mc/mark-all-like-this)
+    (if (and (mc--no-region-and-in-sgmlish-mode)
+             (mc--on-tag-name-p))
+        (mc/mark-sgml-tag-pair)
+      (let ((before (mc/num-cursors)))
+        (unless (eq last-command 'mc/mark-all-like-this-dwim)
+          (setq mc--restrict-mark-all-to-symbols nil))
+        (unless (use-region-p)
+          (mc--mark-symbol-at-point)
+          (setq mc--restrict-mark-all-to-symbols t))
+        (if mc--restrict-mark-all-to-symbols
+            (mc/mark-all-symbols-like-this-in-defun)
+          (mc/mark-all-like-this-in-defun))
+        (when (<= (mc/num-cursors) before)
+          (if mc--restrict-mark-all-to-symbols
+              (mc/mark-all-symbols-like-this)
+            (mc/mark-all-like-this)))
+        (when (<= (mc/num-cursors) before)
+          (mc/mark-all-like-this))))))
+
+(defun mc--no-region-and-in-sgmlish-mode ()
+  (and (not (use-region-p))
+       (derived-mode-p 'sgml-mode)))
+
+(defun mc--in-defun ()
+  (bounds-of-thing-at-point 'defun))
+
+;;;###autoload
+(defun mc/mark-all-like-this-in-defun ()
+  "Mark all like this in defun."
+  (interactive)
+  (if (mc--in-defun)
+      (save-restriction
+        (widen)
+        (narrow-to-defun)
+        (mc/mark-all-like-this))
+    (mc/mark-all-like-this)))
+
+;;;###autoload
+(defun mc/mark-all-words-like-this-in-defun ()
+  "Mark all words like this in defun."
+  (interactive)
+  (if (mc--in-defun)
+      (save-restriction
+        (widen)
+        (narrow-to-defun)
+        (mc/mark-all-words-like-this))
+    (mc/mark-all-words-like-this)))
+
+;;;###autoload
+(defun mc/mark-all-symbols-like-this-in-defun ()
+  "Mark all symbols like this in defun."
+  (interactive)
+  (if (mc--in-defun)
+      (save-restriction
+        (widen)
+        (narrow-to-defun)
+        (mc/mark-all-symbols-like-this))
+    (mc/mark-all-symbols-like-this)))
+
+(defun mc--mark-symbol-at-point ()
+  "Select the symbol under cursor"
+  (interactive)
+  (when (not (use-region-p))
+    (let ((b (bounds-of-thing-at-point 'symbol)))
+      (goto-char (car b))
+      (set-mark (cdr b)))))
+
+(defun mc--get-nice-sgml-context ()
+  (car
+   (last
+    (progn
+      (when (looking-at "<") (forward-char 1))
+      (when (looking-back ">") (forward-char -1))
+      (sgml-get-context)))))
+
+(defun mc--on-tag-name-p ()
+  (let* ((context (save-excursion (mc--get-nice-sgml-context)))
+         (tag-name-len (length (aref context 4)))
+         (beg (aref context 2))
+         (end (+ beg tag-name-len (if (eq 'open (aref context 1)) 1 3))))
+    (and context
+         (>= (point) beg)
+         (<= (point) end))))
+
+;;;###autoload
+(defun mc/mark-sgml-tag-pair ()
+  "Mark the tag we're in and its pair for renaming."
+  (interactive)
+  (when (not (mc--inside-tag-p))
+    (error "Place point inside tag to rename."))
+  (let ((context (mc--get-nice-sgml-context)))
+    (if (looking-at "</")
+        (setq context (car (last (sgml-get-context)))))
+    (goto-char (aref context 2))
+    (let* ((tag-name (aref context 4))
+           (num-chars (length tag-name))
+           (master-start (1+ (point)))
+           (mirror-end (save-excursion
+                         (sgml-skip-tag-forward 1)
+                         (1- (point)))))
+      (goto-char (- mirror-end num-chars))
+      (set-mark mirror-end)
+      (mc/create-fake-cursor-at-point)
+      (goto-char master-start)
+      (set-mark (+ (point) num-chars))))
+  (mc/maybe-multiple-cursors-mode))
+
+(defun mc--inside-tag-p ()
+  (save-excursion
+    (not (null (sgml-get-context)))))
+
 (provide 'mc-mark-more)
 
 ;;; mc-mark-more.el ends here

multiple-cursors-core.el

@@ -25,7 +25,7 @@
 
 ;;; Code:
 
-(eval-when-compile (require 'cl))
+(require 'cl)
 
 (require 'rect)
 
@@ -49,12 +49,15 @@
        (setq buffer-undo-list ;; otherwise add a function to activate this cursor
              (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list)))))
 
+(defun mc/all-fake-cursors (&optional start end)
+  (remove-if-not 'mc/fake-cursor-p
+                 (overlays-in (or start (point-min))
+                              (or end   (point-max)))))
+
 (defmacro mc/for-each-fake-cursor (&rest forms)
   "Runs the body for each fake cursor, bound to the name cursor"
-  `(mapc #'(lambda (cursor)
-             (when (mc/fake-cursor-p cursor)
-               ,@forms))
-         (overlays-in (point-min) (point-max))))
+  `(mapc #'(lambda (cursor) ,@forms)
+         (mc/all-fake-cursors)))
 
 (defmacro mc/save-excursion (&rest forms)
   "Saves and restores all the state that multiple-cursors cares about."
@@ -115,6 +118,11 @@ highlights the entire width of the window."
     (overlay-put overlay 'type 'additional-region)
     overlay))
 
+(defvar mc/cursor-specific-vars '(autopair-action
+                                  autopair-wrap-action
+                                  er/history)
+  "A list of vars that need to be tracked on a per-cursor basis.")
+
 (defun mc/store-current-state-in-overlay (o)
   "Store relevant info about point and mark in the given overlay."
   (overlay-put o 'point (set-marker (make-marker) (point)))
@@ -125,7 +133,8 @@ highlights the entire width of the window."
   (overlay-put o 'mark-active mark-active)
   (overlay-put o 'yank-undo-function yank-undo-function)
   (overlay-put o 'kill-ring-yank-pointer kill-ring-yank-pointer)
-  (when (boundp 'er/history) (overlay-put o 'er/history er/history))
+  (dolist (var mc/cursor-specific-vars)
+    (when (boundp var) (overlay-put o var (symbol-value var))))
   o)
 
 (defun mc/restore-state-from-overlay (o)
@@ -138,7 +147,8 @@ highlights the entire width of the window."
   (setq mark-active (overlay-get o 'mark-active))
   (setq yank-undo-function (overlay-get o 'yank-undo-function))
   (setq kill-ring-yank-pointer (overlay-get o 'kill-ring-yank-pointer))
-  (when (boundp 'er/history) (setq er/history (overlay-get o 'er/history))))
+  (dolist (var mc/cursor-specific-vars)
+    (when (boundp var) (set var (overlay-get o var)))))
 
 (defun mc/remove-fake-cursor (o)
   "Delete overlay with state, including dependent overlays and markers."
@@ -183,6 +193,7 @@ Saves the current state in the overlay to be restored later."
   (run-hooks 'pre-command-hook)
   (unless (eq this-command 'ignore)
     (call-interactively cmd))
+  (run-hooks 'post-command-hook)
   (when deactivate-mark (deactivate-mark)))
 
 (defvar mc--executing-command-for-fake-cursor nil)
@@ -297,6 +308,13 @@ not be recognized through the command-remapping lookup."
      (message "[mc] problem in `mc/execute-this-command-for-all-cursors': %s"
               (error-message-string error)))))
 
+;; execute-kbd-macro should never be run for fake cursors. The real cursor will
+;; execute the keyboard macro, resulting in new commands in the command loop,
+;; and the fake cursors can pick up on those instead.
+(defadvice execute-kbd-macro (around skip-fake-cursors activate)
+  (unless mc--executing-command-for-fake-cursor
+    ad-do-it))
+
 (defun mc/execute-this-command-for-all-cursors-1 ()
   "Used with post-command-hook to execute supported commands for all cursors.
 
@@ -308,35 +326,35 @@ Some commands are so unsupported that they are even prevented for
 the original cursor, to inform about the lack of support."
   (unless mc--executing-command-for-fake-cursor
 
-   (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
-       (multiple-cursors-mode 0)
+    (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
+        (multiple-cursors-mode 0)
 
-     (when this-original-command
-       (let ((original-command (or mc--this-command
-                                   (command-remapping this-original-command)
-                                   this-original-command)))
+      (when this-original-command
+        (let ((original-command (or mc--this-command
+                                    (command-remapping this-original-command)
+                                    this-original-command)))
 
-         ;; skip keyboard macros, since they will generate actual commands that are
-         ;; also run in the command loop - we'll handle those later instead.
-         (when (functionp original-command)
+          ;; skip keyboard macros, since they will generate actual commands that are
+          ;; also run in the command loop - we'll handle those later instead.
+          (when (functionp original-command)
 
-           ;; if it's a lambda, we can't know if it's supported or not
-           ;; - so go ahead and assume it's ok, because we're just optimistic like that
-           (if (not (symbolp original-command))
-               (mc/execute-command-for-all-fake-cursors original-command)
+            ;; if it's a lambda, we can't know if it's supported or not
+            ;; - so go ahead and assume it's ok, because we're just optimistic like that
+            (if (not (symbolp original-command))
+                (mc/execute-command-for-all-fake-cursors original-command)
 
-             ;; otherwise it's a symbol, and we can be more thorough
-             (if (get original-command 'mc--unsupported)
-                 (message "%S is not supported with multiple cursors%s"
-                          original-command
-                          (get original-command 'mc--unsupported))
-               (when (and original-command
-                          (not (memq original-command mc--default-cmds-to-run-once))
-                          (not (memq original-command mc/cmds-to-run-once))
-                          (or (memq original-command mc--default-cmds-to-run-for-all)
-                              (memq original-command mc/cmds-to-run-for-all)
-                              (mc/prompt-for-inclusion-in-whitelist original-command)))
-                 (mc/execute-command-for-all-fake-cursors original-command))))))))))
+              ;; otherwise it's a symbol, and we can be more thorough
+              (if (get original-command 'mc--unsupported)
+                  (message "%S is not supported with multiple cursors%s"
+                           original-command
+                           (get original-command 'mc--unsupported))
+                (when (and original-command
+                           (not (memq original-command mc--default-cmds-to-run-once))
+                           (not (memq original-command mc/cmds-to-run-once))
+                           (or (memq original-command mc--default-cmds-to-run-for-all)
+                               (memq original-command mc/cmds-to-run-for-all)
+                               (mc/prompt-for-inclusion-in-whitelist original-command)))
+                  (mc/execute-command-for-all-fake-cursors original-command))))))))))
 
 (defun mc/remove-fake-cursors ()
   "Remove all fake cursors.
@@ -410,9 +428,16 @@ They are temporarily disabled when multiple-cursors are active.")
   (mapc 'mc/enable-minor-mode mc/temporarily-disabled-minor-modes)
   (setq mc/temporarily-disabled-minor-modes nil))
 
+(defcustom mc/mode-line
+  `(" mc:" (:eval (format ,(propertize "%d" 'face 'font-lock-warning-face)
+                          (mc/num-cursors))))
+  "What to display in the mode line while multiple-cursors-mode is active."
+  :group 'multiple-cursors)
+(put 'mc/mode-line 'risky-local-variable t)
+
 (define-minor-mode multiple-cursors-mode
   "Mode while multiple cursors are active."
-  nil " mc" mc/keymap
+  nil mc/mode-line mc/keymap
   (if multiple-cursors-mode
       (progn
         (mc/temporarily-disable-unsupported-minor-modes)
@@ -429,6 +454,12 @@ They are temporarily disabled when multiple-cursors are active.")
 
 (add-hook 'after-revert-hook #'(lambda () (multiple-cursors-mode 0)))
 
+(defun mc/maybe-multiple-cursors-mode ()
+  "Enable multiple-cursors-mode if there is more than one currently active cursor."
+  (if (> (mc/num-cursors) 1)
+      (multiple-cursors-mode 1)
+    (multiple-cursors-mode 0)))
+
 (defmacro unsupported-cmd (cmd msg)
   "Adds command to list of unsupported commands and prevents it
 from being executed if in multiple-cursors-mode."
@@ -472,6 +503,20 @@ from being executed if in multiple-cursors-mode."
   "The position of the file that keeps track of your preferences
 for running commands with multiple cursors.")
 
+(defun mc/dump-list (list-symbol)
+  "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
+  (symbol-macrolet ((value (symbol-value list-symbol)))
+    (insert "(setq " (symbol-name list-symbol) "\n"
+            "      '(")
+    (newline-and-indent)
+    (set list-symbol
+         (sort value (lambda (x y) (string-lessp (symbol-name x)
+                                                 (symbol-name y)))))
+    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent))
+          value)
+    (insert "))")
+    (newline)))
+
 (defun mc/save-lists ()
   "Saves preferences for running commands with multiple cursors to `mc/list-file'"
   (with-temp-file mc/list-file
@@ -481,21 +526,9 @@ for running commands with multiple cursors.")
     (insert ";; It keeps track of your preferences for running commands with multiple cursors.")
     (newline)
     (newline)
-    (insert "(setq mc/cmds-to-run-for-all '(")
-    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent)) mc/cmds-to-run-for-all)
-    (when mc/cmds-to-run-for-all
-      (forward-line -1)
-      (end-of-line))
-    (insert "))")
+    (mc/dump-list 'mc/cmds-to-run-for-all)
     (newline)
-    (newline)
-    (insert "(setq mc/cmds-to-run-once '(")
-    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent)) mc/cmds-to-run-once)
-    (when mc/cmds-to-run-once
-      (forward-line -1)
-      (end-of-line))
-    (insert "))")
-    (newline)))
+    (mc/dump-list 'mc/cmds-to-run-once)))
 
 (defvar mc/cmds-to-run-once nil
   "Commands to run only once in multiple-cursors-mode.")
@@ -507,9 +540,20 @@ for running commands with multiple cursors.")
                                      mc/edit-ends-of-lines
                                      mc/edit-beginnings-of-lines
                                      mc/mark-next-like-this
+                                     mc/mark-next-word-like-this
+                                     mc/mark-next-symbol-like-this
                                      mc/mark-previous-like-this
-                                     mc/mark-more-like-this-extended
+                                     mc/mark-previous-word-like-this
+                                     mc/mark-previous-symbol-like-this
                                      mc/mark-all-like-this
+                                     mc/mark-all-words-like-this
+                                     mc/mark-all-symbols-like-this
+                                     mc/mark-more-like-this-extended
+                                     mc/mark-all-like-this-in-defun
+                                     mc/mark-all-words-like-this-in-defun
+                                     mc/mark-all-symbols-like-this-in-defun
+                                     mc/mark-all-like-this-dwim
+                                     mc/mark-sgml-tag-pair
                                      mc/cycle-forward
                                      mc/cycle-backward
                                      rrm/switch-to-multiple-cursors
@@ -534,6 +578,7 @@ for running commands with multiple cursors.")
                                      describe-function
                                      describe-bindings
                                      describe-prefix-bindings
+                                     view-echo-area-messages
                                      other-window
                                      kill-buffer-and-window
                                      split-window-right
@@ -541,6 +586,8 @@ for running commands with multiple cursors.")
                                      delete-other-windows
                                      toggle-window-split
                                      mwheel-scroll
+                                     scroll-up-command
+                                     scroll-down-command
                                      mouse-set-point
                                      mouse-drag-region
                                      quit-window
@@ -594,6 +641,10 @@ for running commands with multiple cursors.")
                                         backward-delete-char-untabify
                                         delete-char delete-forward-char
                                         delete-backward-char
+                                        c-electric-backspace
+                                        org-delete-backward-char
+                                        paredit-backward-delete
+                                        autopair-backspace
                                         just-one-space
                                         zap-to-char
                                         end-of-line
@@ -629,4 +680,9 @@ for running commands with multiple cursors.")
 
 (provide 'multiple-cursors-core)
 
+;; Local Variables:
+;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
+;; End:
+
 ;;; multiple-cursors-core.el ends here

multiple-cursors-pkg.el

@@ -1,2 +1,2 @@
-(define-package "multiple-cursors" "1.1.3"
+(define-package "multiple-cursors" "1.1.5"
                 "Multiple cursors for Emacs.")

multiple-cursors.el

@@ -23,106 +23,136 @@
 ;; Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
 ;; there are kinks. Don't be afraid tho, I've been using it since 2011 with
 ;; great success and much merriment.
-;;
+
 ;; ## Basic usage
-;;
+
 ;; Start out with:
-;;
+
 ;;     (require 'multiple-cursors)
-;;
+
+;; Then you have to set up your keybindings - multiple-cursors doesn't presume to
+;; know how you'd like them laid out. Here are some examples:
+
 ;; When you have an active region that spans multiple lines, the following will
 ;; add a cursor to each line:
-;;
+
 ;;     (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
-;;
+
 ;; When you want to add multiple cursors not based on continuous lines, but based on
 ;; keywords in the buffer, use:
-;;
+
 ;;     (global-set-key (kbd "C->") 'mc/mark-next-like-this)
 ;;     (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
 ;;     (global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
-;;
+
 ;; First mark the word, then add more cursors.
-;;
+
 ;; To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
 ;; first disable multiple regions before disabling multiple cursors. If you want to
 ;; insert a newline in multiple-cursors-mode, use `C-j`.
-;;
-;;
-;; ## More commands to play around with
-;;
-;; I've set up my key-bindings like so:
-;;
-;;     ;; From active region to multiple cursors:
-;;     (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
-;;     (global-set-key (kbd "C-S-c C-e") 'mc/edit-ends-of-lines)
-;;     (global-set-key (kbd "C-S-c C-a") 'mc/edit-beginnings-of-lines)
-;;
-;; When you have an active region that spans multiple lines, the preceeding three
-;; commands will add one cursor to each line.
-;;
-;;     ;; Rectangular region mode
-;;     (global-set-key (kbd "H-SPC") 'set-rectangular-region-anchor)
-;;
-;; Think of this one as `set-mark` except you're marking a rectangular region. It is
-;; an exceedingly quick way of adding multiple cursors to multiple lines.
-;;
-;;     ;; Mark more like this
-;;     (global-set-key (kbd "M-æ") 'mc/mark-all-like-this)
-;;     (global-set-key (kbd "C-å") 'mc/mark-previous-like-this)
-;;     (global-set-key (kbd "C-æ") 'mc/mark-next-like-this)
-;;     (global-set-key (kbd "C-Æ") 'mc/mark-more-like-this-extended)
-;;     (global-set-key (kbd "M-å") 'mc/mark-all-in-region)
-;;
-;; Okay, yes, I have a crazy norwegian keyboard. Regardless, these will look at
-;; whatever you've got selected at the moment, and mark more places like that in
-;; the buffer.
-;;
+
+;; ## Video
+
+;; You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.com/e13.html).
+
+;; ## Command overview
+
+;; ### Mark one more occurrence
+
+;;  - `mc/mark-next-like-this`: Adds a cursor and region at the next part of the buffer forwards that matches the current region.
+;;  - `mc/mark-next-word-like-this`: Like `mc/mark-next-like-this` but only for whole words.
+;;  - `mc/mark-next-symbol-like-this`: Like `mc/mark-next-like-this` but only for whole symbols.
+;;  - `mc/mark-previous-like-this`: Adds a cursor and region at the next part of the buffer backwards that matches the current region.
+;;  - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
+;;  - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
+;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
+
+;; ### Mark many occurrences
+
+;;  - `mc/mark-all-like-this`: Marks all parts of the buffer that matches the current region.
+;;  - `mc/mark-all-words-like-this`: Like `mc/mark-all-like-this` but only for whole words.
+;;  - `mc/mark-all-symbols-like-this`: Like `mc/mark-all-like-this` but only for whole symbols.
+;;  - `mc/mark-all-in-region`: Prompts for a string to match in the region, adding cursors to all of them.
+;;  - `mc/mark-all-like-this-in-defun`: Marks all parts of the current defun that matches the current region.
+;;  - `mc/mark-all-words-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole words.
+;;  - `mc/mark-all-symbols-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole symbols.
+;;  - `mc/mark-all-like-this-dwim`: Tries to be smart about marking everything you want. Can be pressed multiple times.
+
+;; ### Special
+
+;;  - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
+;;  - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
+
+;; ## Tips and tricks
+
+;; - To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
+;;   first disable multiple regions before disabling multiple cursors. If you want to
+;;   insert a newline in multiple-cursors-mode, use `C-j`.
+
+;; - Sometimes you end up with cursors outside of your view. You can
+;;   scroll the screen to center on each cursor with `C-v` and `M-v`.
+
+;; - Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
+;;   on the next line.
+
+;; - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
+
+;; - Notice that the number of cursors active can be seen in the modeline.
+
+;; - If you would like to keep the global bindings clean, and get custom keybindings
+;;   when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).
+
 ;; BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
 ;; right next to the key for `er/expand-region`.
-;;
-;;
+
 ;; ## Unknown commands
-;;
+
 ;; Multiple-cursors uses two lists of commands to know what to do: the run-once list
 ;; and the run-for-all list. It comes with a set of defaults, but it would be beyond silly
 ;; to try and include all the known Emacs commands.
-;;
+
 ;; So that's why multiple-cursors occasionally asks what to do about a command. It will
 ;; then remember your choice by saving it in `~/.emacs.d/.mc-lists.el`. You can change
 ;; the location with:
-;;
+
 ;;     (setq mc/list-file "/my/preferred/file")
-;;
-;;
+
 ;; ## Known limitations
-;;
+
 ;; * isearch-forward and isearch-backward aren't supported with multiple cursors.
 ;;   You should feel free to add a simplified version that can work with it.
 ;; * Commands run with `M-x` won't be repeated for all cursors.
 ;; * All key bindings that refer to lambdas are always run for all cursors. If you
 ;;   need to limit it, you will have to give it a name.
 ;; * Redo might screw with your cursors. Undo works very well.
-;;
-;;
+
 ;; ## Contribute
-;;
+
 ;; Yes, please do. There's a suite of tests, so remember to add tests for your
 ;; specific feature, or I might break it later.
-;;
+
 ;; You'll find the repo at:
-;;
+
 ;;     https://github.com/magnars/multiple-cursors.el
-;;
+
 ;; To fetch the test dependencies:
-;;
+
 ;;     $ cd /path/to/multiple-cursors
 ;;     $ git submodule update --init
-;;
+
 ;; Run the tests with:
-;;
+
 ;;     $ ./util/ecukes/ecukes --graphical
-;;
+
+;; ## Contributors
+
+;; * [Takafumi Arakaki](https://github.com/tkf) made .mc-lists.el diff friendly
+;; * [Marco Baringer](https://github.com/segv) contributed looping to mc/cycle and adding cursors without region for mark-more.
+;; * [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line
+;; * [Fuco](https://github.com/Fuco1) added the first version of `mc/mark-all-like-this-dwim`
+
+;; Thanks!
+
 ;;; Code:
 
 (require 'mc-edit-lines)

run-travis-ci.sh

@@ -1,20 +1,12 @@
-#!/bin/sh
+#!/bin/sh -e
 
 cd "$(dirname "$0")"
 
-set_default () {
-  eval "
-if [ -z \$$1 ]; then
-  $1=$2
-fi
-"
-}
-
-set_default ECUKES_EMACS "$(which emacs)"
+ECUKES_EMACS=${ECUKES_EMACS:-$(which emacs)}
 
 echo "*** Emacs version ***"
-echo "ECUKES_EMACS =" $(which $ECUKES_EMACS)
-$ECUKES_EMACS --version
+echo "ECUKES_EMACS = $ECUKES_EMACS"
+"$ECUKES_EMACS" --version
 echo
 
 exec ./util/ecukes/ecukes --graphical

util/vendor/wrap-region.el

@@ -0,0 +1,329 @@
+;;; wrap-region.el --- Wrap text with punctation or tag
+
+;; Copyright (C) 2008-2012 Johan Andersson
+
+;; Author: Johan Andersson <johan.rejeep@gmail.com>
+;; Maintainer: Johan Andersson <johan.rejeep@gmail.com>
+;; Version: 0.6.0
+;; Keywords: speed, convenience
+;; URL: http://github.com/rejeep/wrap-region
+
+;; This file is NOT part of GNU Emacs.
+
+
+;;; License:
+
+;; 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
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+
+;;; Commentary:
+
+;; wrap-region is a minor mode that wraps a region with
+;; punctuations. For tagged markup modes, such as HTML and XML, it
+;; wraps with tags.
+;;
+;; To use wrap-region, make sure that this file is in Emacs load-path:
+;;   (add-to-list 'load-path "/path/to/directory/or/file")
+;;
+;; Then require wrap-region:
+;;   (require 'wrap-region)
+
+;; To start wrap-region:
+;;   (wrap-region-mode t) or M-x wrap-region-mode
+;;
+;; If you only want wrap-region active in some mode, use hooks:
+;;   (add-hook 'ruby-mode-hook 'wrap-region-mode)
+;;
+;; Or if you want to activate it in all buffers, use the global mode:
+;;   (wrap-region-global-mode t)
+
+;; To wrap a region, select that region and hit one of the punctuation
+;; keys. In "tag-modes"" (see `wrap-region-tag-active-modes'), "<" is
+;; replaced and wraps the region with a tag. To activate this behavior
+;; in a mode that is not default:
+;;   (add-to-list 'wrap-region-tag-active-modes 'some-tag-mode)
+;;
+;; `wrap-region-table' contains the default punctuations
+;; that wraps. You can add and remove new wrappers by using the
+;; functions `wrap-region-add-wrapper' and
+;; `wrap-region-remove-wrapper' respectively.
+;;   (wrap-region-add-wrapper "`" "'")                  ; hit ` then region -> `region'
+;;   (wrap-region-add-wrapper "/*" "*/" "/")            ; hit / then region -> /*region*/
+;;   (wrap-region-add-wrapper "$" "$" nil 'latex-mode)  ; hit $ then region -> $region$ in latex-mode
+;;   (wrap-region-remove-wrapper "(")
+;;   (wrap-region-remove-wrapper "$" 'latex-mode)
+;;
+;; Some modes may have conflicting key bindings with wrap-region. To
+;; avoid conflicts, the list `wrap-region-except-modes' contains names
+;; of modes where wrap-region should not be activated (note, only in
+;; the global mode). You can add new modes like this:
+;;   (add-to-list 'wrap-region-except-modes 'conflicting-mode)
+
+
+;;; Code:
+
+(require 'edmacro)
+(eval-when-compile
+  (require 'cl))
+
+
+(defstruct wrap-region-wrapper key left right modes)
+
+(defvar wrap-region-mode-map (make-sparse-keymap)
+  "Keymap for `wrap-region-mode'.")
+
+(defvar wrap-region-table (make-hash-table :test 'equal)
+  "Table with wrapper pairs.")
+
+(defvar wrap-region-tag-active-modes '(html-mode sgml-mode rhtml-mode nxml-mode nxhtml-mode)
+  "List of modes that uses tags.")
+
+(defvar wrap-region-except-modes '(calc-mode dired-mode)
+  "A list of modes in which `wrap-region-mode' should not be activated.")
+
+(defvar wrap-region-hook nil
+  "Called when `wrap-region-mode' is turned on.")
+
+(defvar wrap-region-before-wrap-hook nil
+  "Called before wrapping.")
+
+(defvar wrap-region-after-wrap-hook nil
+  "Called after wrapping.")
+
+(defvar wrap-region-only-with-negative-prefix nil
+  "Only wrap if the trigger key is prefixed with a negative value.")
+
+(defvar wrap-region-keep-mark nil
+  "Keep the wrapped region active.")
+
+(defun wrap-region-trigger (arg key)
+  "Called when trigger key is pressed."
+  (let* ((wrapper (wrap-region-find key)))
+    (if (and wrapper
+             (region-active-p)
+             (if wrap-region-only-with-negative-prefix (< arg 0) t))
+        (if (wrap-region-insert-tag-p key)
+            (wrap-region-with-tag)
+          (wrap-region-with-punctuations
+           (wrap-region-wrapper-left wrapper)
+           (wrap-region-wrapper-right wrapper)))
+      (wrap-region-fallback key))))
+
+(defun wrap-region-find (key)
+  "Find first wrapper with trigger KEY that should be active in MAJOR-MODE."
+  (let ((wrappers (gethash key wrap-region-table)))
+    (or
+     (find-if
+      (lambda (wrapper)
+        (member major-mode (wrap-region-wrapper-modes wrapper)))
+      wrappers)
+     (find-if
+      (lambda (wrapper)
+        (not (wrap-region-wrapper-modes wrapper)))
+      wrappers))))
+
+(defun wrap-region-insert-tag-p (key)
+  "Check if tag should be inserted or not."
+  (and
+   (equal key "<")
+   (member major-mode wrap-region-tag-active-modes)))
+
+(defun wrap-region-with-tag ()
+  "Wraps region with tag."
+  (let* ((tag (read-string "Enter Tag (with optional attributes): "))
+         (split (split-string tag " "))
+         (tag-name (car split))
+         (left (concat "<" tag ">"))
+         (right (concat "</" tag-name ">")))
+    (wrap-region-with left right)))
+
+(defun wrap-region-with-punctuations (left right)
+  "Wraps region with LEFT and RIGHT punctuations."
+  (wrap-region-with left right))
+
+(defun wrap-region-with (left right)
+  "Wraps region with LEFT and RIGHT."
+  (run-hooks 'wrap-region-before-wrap-hook)
+  (let ((beg (region-beginning))
+        (end (region-end))
+        (pos (point))
+        (deactivate-mark nil))
+    (save-excursion
+      (goto-char beg)
+      (insert left)
+      (goto-char (+ end (length left)))
+      (insert right))
+    (if wrap-region-keep-mark
+        (let* ((beg-p (eq beg pos))
+               (beg* (+ beg (length left)))
+               (end* (+ end (length left)))
+               (pos* (if beg-p beg* end*)))
+          (push-mark (if beg-p end* beg*) nil t)
+          (goto-char (if beg-p beg* end*)))
+      (deactivate-mark)))
+  (run-hooks 'wrap-region-after-wrap-hook))
+
+(defun wrap-region-fallback (key)
+  "Execute function that KEY was bound to before `wrap-region-mode'."
+  (let ((wrap-region-mode nil))
+    (execute-kbd-macro
+     (edmacro-parse-keys key))))
+
+(defun wrap-region-add-wrappers (wrappers)
+  "Add WRAPPERS by calling `wrap-region-add-wrapper' for each one."
+  (mapc
+   (lambda (wrapper)
+     (apply 'wrap-region-add-wrapper wrapper))
+   wrappers))
+
+(defun wrap-region-add-wrapper (left right &optional key mode-or-modes)
+  "Add new LEFT and RIGHT wrapper.
+
+Optional KEY is the trigger key and MODE-OR-MODES is a single
+mode or multiple modes that the wrapper should trigger in."
+  (or key (setq key left))
+  (let ((wrappers (gethash key wrap-region-table))
+        (modes
+         (if mode-or-modes
+             (if (listp mode-or-modes)
+                 mode-or-modes
+               (list mode-or-modes)))))
+    (if wrappers
+        (let ((wrapper-exactly-same
+               (find-if
+                (lambda (wrapper)
+                  (and
+                   (equal (wrap-region-wrapper-key wrapper) key)
+                   (equal (wrap-region-wrapper-left wrapper) left)
+                   (equal (wrap-region-wrapper-right wrapper) right)))
+                wrappers)))
+          (if wrapper-exactly-same
+              (when (wrap-region-wrapper-modes wrapper-exactly-same)
+                (if modes
+                    (setf
+                     (wrap-region-wrapper-modes wrapper-exactly-same)
+                     (union modes (wrap-region-wrapper-modes wrapper-exactly-same)))
+                  (let ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right)))
+                    (puthash key (cons new-wrapper wrappers) wrap-region-table))))
+            (let* ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right :modes modes))
+                   (wrapper-same-trigger
+                    (find-if
+                     (lambda (wrapper)
+                       (equal (wrap-region-wrapper-key wrapper) key))
+                     wrappers))
+                   (wrapper-same-trigger-modes
+                    (wrap-region-wrapper-modes wrapper-same-trigger)))
+              (when (and wrapper-same-trigger wrapper-same-trigger-modes)
+                (let ((new-modes (nset-difference (wrap-region-wrapper-modes wrapper-same-trigger) modes)))
+                  (if new-modes
+                      (setf (wrap-region-wrapper-modes wrapper-same-trigger) new-modes)
+                    (setq wrappers (delete wrapper-same-trigger wrappers)))))
+              (puthash key (cons new-wrapper wrappers) wrap-region-table))))
+      (let ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right :modes modes)))
+        (puthash key (list new-wrapper) wrap-region-table))))
+  (wrap-region-define-trigger key))
+
+(defun wrap-region-remove-wrapper (key &optional mode-or-modes)
+  "Remove wrapper with trigger KEY or exclude from MODE-OR-MODES.
+
+If MODE-OR-MODES is not present, all wrappers for KEY are removed."
+  (if mode-or-modes
+      (let ((wrappers (gethash key wrap-region-table))
+            (modes
+             (if mode-or-modes
+                 (if (listp mode-or-modes)
+                     mode-or-modes
+                   (list mode-or-modes)))))
+        (mapc
+         (lambda (mode)
+           (let ((wrapper-including-mode
+                  (find-if
+                   (lambda (wrapper)
+                     (member mode (wrap-region-wrapper-modes wrapper)))
+                   wrappers)))
+             (when wrapper-including-mode
+               (let ((new-modes (delete mode (wrap-region-wrapper-modes wrapper-including-mode))))
+                 (if new-modes
+                     (setf (wrap-region-wrapper-modes wrapper-including-mode) new-modes)
+                   (puthash key (delete wrapper-including-mode wrappers) wrap-region-table))))))
+         modes))
+    (wrap-region-destroy-wrapper key)))
+
+(defun wrap-region-destroy-wrapper (key)
+  "Remove the wrapper bound to KEY, no questions asked."
+  (remhash key wrap-region-table)
+  (wrap-region-unset-key key))
+
+(defun wrap-region-define-wrappers ()
+  "Defines defaults wrappers."
+  (mapc
+   (lambda (pair)
+     (apply 'wrap-region-add-wrapper pair))
+   '(("\"" "\"")
+     ("'"  "'")
+     ("("  ")")
+     ("{"  "}")
+     ("["  "]")
+     ("<"  ">"))))
+
+(defun wrap-region-define-trigger (key)
+  "Defines KEY as wrapper."
+  (wrap-region-define-key
+   key
+   `(lambda (arg)
+      (interactive "p")
+      (wrap-region-trigger arg ,key))))
+
+(defun wrap-region-unset-key (key)
+  "Remove KEY from `wrap-region-mode-map'."
+  (wrap-region-define-key key))
+
+(defun wrap-region-define-key (key &optional fn)
+  "Binds KEY to FN in `wrap-region-mode-map'."
+  (define-key wrap-region-mode-map (read-kbd-macro key) fn))
+
+
+;;;###autoload
+(define-minor-mode wrap-region-mode
+  "Wrap region with stuff."
+  :init-value nil
+  :lighter " wr"
+  :keymap wrap-region-mode-map
+  (when wrap-region-mode
+    (wrap-region-define-wrappers)
+    (run-hooks 'wrap-region-hook)))
+
+;;;###autoload
+(defun turn-on-wrap-region-mode ()
+  "Turn on `wrap-region-mode'"
+  (interactive)
+  (unless (member major-mode wrap-region-except-modes)
+    (wrap-region-mode +1)))
+
+;;;###autoload
+(defun turn-off-wrap-region-mode ()
+  "Turn off `wrap-region-mode'."
+  (interactive)
+  (wrap-region-mode -1))
+
+;;;###autoload
+(define-globalized-minor-mode wrap-region-global-mode
+  wrap-region-mode
+  turn-on-wrap-region-mode)
+
+(provide 'wrap-region)
+
+;;; wrap-region.el ends here