Release 1.2.3

.gitignore

@@ -1,3 +1 @@
-elpa
-*.elc
-/.ecukes-failing-scenarios
+elpa

.travis.yml

@@ -12,7 +12,7 @@ before_install:
       sudo apt-get install -qq
           emacs24 emacs24-el emacs24-common-non-dfsg;
     fi
-  - curl -fsSkL https://raw.github.com/cask/cask/master/go | python
+  - curl -fsSkL https://raw.github.com/rejeep/cask.el/master/go | sh
   - export PATH="/home/travis/.cask/bin:$PATH"
   - cask
 env:

Cask

@@ -1,4 +1,3 @@
-(source gnu)
 (source melpa)
 
 (package-file "multiple-cursors.el")

README.md

@@ -1,38 +1,9 @@
 # multiple-cursors.el [![Build Status](https://secure.travis-ci.org/magnars/multiple-cursors.el.png)](http://travis-ci.org/magnars/multiple-cursors.el)
 
 Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
-there are kinks. Don't be afraid though, I've been using it since 2011 with
+there are kinks. Don't be afraid tho, I've been using it since 2011 with
 great success and much merriment.
 
-## Maintenance warning
-
-I use this package every day, and have been doing so for years. It just works.
-At least, it works for all my use cases. And if it breaks somehow, I fix it.
-
-However, it has become painfully clear to me that I don't have time to fix
-problems I don't have. It's been years since I could keep pace with the issues
-and pull requests. Whenever I try, I keep getting feedback that my fix isn't
-good enough by some standard I don't particularly care about.
-
-So, I have closed the issue tracker and the pull requests. I hope you can
-happily use this package, just like I do. If it doesn't work for you, then I'm
-sorry. Thankfully Emacs is infinitely malleable, you can probably fix it
-yourself.
-
-TLDR: *I am still maintaining this package*, but I am no longer crowdsourcing a list of issues.
-
-## Installation
-
-I highly recommend installing multiple-cursors through `package.el`.
-
-It's available on [MELPA](http://melpa.org/) and [MELPA Stable](http://stable.melpa.org):
-
-    M-x package-install multiple-cursors
-
-The package depends on the `cl-lib` package, so if you do not use
-`package.el` or have a recent Emacs, you would need to install that
-too: see [GNU ELPA](http://elpa.gnu.org/packages/cl-lib.html).
-
 ## Basic usage
 
 Start out with:
@@ -60,10 +31,6 @@ 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`.
 
-## Important note
-
-Multiple cursors does not do well when you invoke its commands with `M-x`. It needs to be bound to keys to work properly. Pull request to fix this is welcome.
-
 ## Video
 
 You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.com/e13.html).
@@ -73,25 +40,22 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
 ### 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-like-this-word`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the word at the point.
- - `mc/mark-next-like-this-symbol`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the symbol at the point.
  - `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-like-this-word`: Adds a cursor and region at the next part of the buffer backwards that matches the current region, if  no region is selected it selects the word at the point.
- - `mc/mark-previous-like-this-symbol`: Adds a cursor and region at the next part of the buffer backwards that matches the current region, if  no region is selected it selects the symbol at the point.
  - `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 occurrences.
+ - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
  - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
- - `mc/mark-pop`: Set a cursor at the current point and move to the next (different) position on the mark stack.  This allows for fine grained control over the placement of cursors.
+ - `mc/pop-mark`: Set a cursor at the current point and move to the next (different) position on the mark stack.  This allows for fine grained control over the placement of cursors.
 
 ### Juggle around with the current cursors
 
  - `mc/unmark-next-like-this`: Remove the cursor furthest down in the buffer.
  - `mc/unmark-previous-like-this`: Remove the cursor furthest up in the buffer.
- - `mc/skip-to-next-like-this`: Remove the cursor furthest down, marking the next occurrence down.
- - `mc/skip-to-previous-like-this`: Remove the cursor furthest up, marking the next occurrence up.
+ - `mc/skip-to-next-like-this`: Remove the cursor furthest down, marking the next occurance down.
+ - `mc/skip-to-previous-like-this`: Remove the cursor furthest up, marking the next occurance up.
+ - `mc/mark-next-like-this-extended`: Temporarily bind the arrow keys to mark/unmark/skip cursors.
 
 ### Mark many occurrences
 
@@ -105,14 +69,13 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
  - `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-dwim`: Tries to be smart about marking everything you want. Can be pressed multiple times.
+ - `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.
  - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
- - `mc/insert-letters`: Insert increasing letters for each cursor, top to bottom.
  - `mc/sort-regions`: Sort the marked regions alphabetically.
  - `mc/reverse-regions`: Reverse the order of the marked regions.
 
@@ -122,20 +85,12 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
   first disable multiple regions before disabling multiple cursors. If you want to
   insert a newline in multiple-cursors-mode, use `C-j`.
 
-- `(define-key mc/keymap (kbd "<return>") nil)` will make `<return>` insert a
-  newline; multiple-cursors-mode can still be disabled with `C-g`.
-
 - 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` or you can
-  press `C-'` to hide all lines without a cursor, press `C-'` again to unhide.
+  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-next-like-this-word` or
-  `mc/mark-next-like-this-symbol` with no region selected. It will
-  mark the word or symbol and add a cursor at the next occurrence
-
 - 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.
@@ -147,9 +102,6 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
 - You can use `mc/reverse-regions` with nothing selected and just one cursor.
   It will then flip the sexp at point and the one below it.
 
-- When you use `mc/edit-lines`, you can give it a positive or negative
-  prefix to change how it behaves on too short lines.
-
 - 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).
 
@@ -180,17 +132,11 @@ the location with:
 
     (setq mc/list-file "/my/preferred/file")
 
-NB! Make sure to do so before requiring multiple-cursors.
-
-It is possible to set multiple-cursors to "run-for-all" for every
-command except for those that are listed in `mc/cmds-to-run-once`. To
-enable this set `mc/always-run-for-all` to non-nil. Add commands to be
-run once to `mc/cmds-to-run-once` in ".mc-lists.el".
 
 ## Known limitations
 
 * isearch-forward and isearch-backward aren't supported with multiple cursors.
-  If you want this functionality, you can use [phi-search](https://github.com/zk-phi/phi-search).
+  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.
@@ -220,21 +166,16 @@ Run the tests with:
 ## Contributors
 
 * [Takafumi Arakaki](https://github.com/tkf) has contributed several small improvements
-* [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, and different options for how to handle short lines in `mc/edit-lines`.
+* [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`
 * [Zach Kost-Smith](https://github.com/smithzvk) added `mc/mark-pop`
-* [Maciej Katafiasz](https://github.com/mathrick) added `mc/mark-all-dwim`
-* [Aleksey Fedotov](https://github.com/lexa) added `mc-hide-unmatched-lines-mode`
-* [Jules Tamagnan](https://github.com/jtamagnan) added `mc/mark-next-like-this-word` and `mc/mark-next-like-this-symbol`
-* [Ingo Lohmar](https://github.com/ilohmar) extended `mc/add-cursor-on-click` to toggle cursors.
-* [Andrea Orru](https://github.com/AndreaOrru) added `mc/mark-previous-like-this-word`/`-symbol`
 
 Thanks!
 
 ## License
 
-Copyright (C) 2012-2016 Magnar Sveen
+Copyright (C) 2012 Magnar Sveen
 
 Author: Magnar Sveen <magnars@gmail.com>
 Keywords: editing cursors

features/edit-lines.feature

@@ -55,86 +55,3 @@ Feature: Switching from a multiline region to multiple cursors
     And I go to the front of the word "there"
     And I press "C-S-c C-S-c"
     Then I should have 2 cursors
-
-  Scenario: Edit default short lines
-    When I insert:
-    """
-    hello
-
-    there
-    """
-    And I go to the end of the word "hello"
-    And I set the mark
-    And I go to the end of the word "there"
-    And I press "C-S-c C-S-c"
-    And I press "you"
-    Then I should see:
-    """
-    helloyou
-    you
-    thereyou
-    """
-
-  Scenario: Pad short lines
-    When I insert:
-    """
-    hello
-
-    there
-    """
-    And I go to the end of the word "hello"
-    And I set the mark
-    And I go to the end of the word "there"
-    And I press "M-1 C-S-c C-S-c"
-    Then I should have 3 cursors
-
-  Scenario: Edit padding short lines
-    When I insert:
-    """
-    hello
-
-    there
-    """
-    And I go to the end of the word "hello"
-    And I set the mark
-    And I go to the end of the word "there"
-    And I press "M-1 C-S-c C-S-c"
-    And I press "you"
-    Then I should see:
-    """
-    helloyou
-         you
-    thereyou
-    """
-
-  Scenario: Skip short lines
-    When I insert:
-    """
-    hello
-
-    there
-    """
-    And I go to the end of the word "hello"
-    And I set the mark
-    And I go to the end of the word "there"
-    And I press "M-- M-1 C-S-c C-S-c"
-    Then I should have 2 cursors
-
-  Scenario: Edit skipping short lines
-    When I insert:
-    """
-    hello
-
-    there
-    """
-    And I go to the end of the word "hello"
-    And I set the mark
-    And I go to the end of the word "there"
-    And I press "M-- M-1 C-S-c C-S-c"
-    And I press "you"
-    Then I should see:
-    """
-    helloyou
-
-    thereyou
-    """

features/hide-unmatched-lines.feature

@@ -1,73 +0,0 @@
-Feature: Hiding lines without cursor
-
-  Scenario: Hiding lines when three cursor active
-    Given I have cursors at "line" in :
-    """
-    0
-    line
-    2
-    3
-    line
-    5
-    6
-    7
-    8
-    9
-    10
-    11
-    line
-    13
-    14
-    15
-    """
-    And I press "C-'"
-    Then I should have 3 cursors
-    Then I should see exactly:
-    """
-    0
-    line
-    2
-    3
-    line
-    5
-    6
-
-    10
-    11
-    line
-    13
-    14
-
-   """
-
-
-  Scenario: Hiding lines when only two cursor active
-    When I insert:
-    """
-      1
-      2
-      3
-      4
-      5
-      text
-      6
-      7
-      8
-      9
-      10
-    """
-    And I go to the front of the word "text"
-    And I press "C->"
-    And I press "C-'"
-    Then I should have 2 cursors
-    Then I should see exactly:
-    """
-
-      4
-      5
-      text
-      6
-      7
-      8
-
-    """

features/insert-letters.feature

@@ -1,25 +0,0 @@
-Feature: Insert increasing letters
-
-  Scenario: Three cursors, a-b-c
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I press "H-3"
-    And I press "SPC"
-    Then I should see "This a text contains the word b text thrice (c text)"
-
-  Scenario: Three cursors, j-k-l
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I press "C-9 H-3"
-    And I press "SPC"
-    Then I should see "This j text contains the word k text thrice (l text)"
-
-  Scenario: Three cursors, z-aa-ab
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I press "C-u 2 5 H-3"
-    And I press "SPC"
-    Then I should see "This z text contains the word aa text thrice (ab text)"
-
-  Scenario: Three cursors, a-b-c
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I press "C-u H-3"
-    And I press "SPC"
-    Then I should see "This e text contains the word f text thrice (g text)"

features/insert-numbers.feature

@@ -11,30 +11,3 @@ Feature: Insert increasing numbers
     When I press "C-9 H-0"
     And I press "SPC"
     Then I should see "This 9 text contains the word 10 text thrice (11 text)"
-
-  Scenario: Three cursors, 9-10-11
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I press "C-u H-0"
-    And I press "SPC"
-    Then I should see "This 4 text contains the word 5 text thrice (6 text)"
-
-  Scenario: Three cursors, 0-1-2, default
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I set mc/insert-numbers-default to 1
-    And I press "H-0"
-    And I press "SPC"
-    Then I should see "This 1 text contains the word 2 text thrice (3 text)"
-
-  Scenario: Three cursors, 9-10-11, default
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I set mc/insert-numbers-default to 1
-    And I press "C-9 H-0"
-    And I press "SPC"
-    Then I should see "This 9 text contains the word 10 text thrice (11 text)"
-
-  Scenario: Three cursors, 9-10-11, default
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I set mc/insert-numbers-default to 1
-    And I press "C-u H-0"
-    And I press "SPC"
-    Then I should see "This 4 text contains the word 5 text thrice (6 text)"

features/mark-all-dwim.feature

@@ -1,16 +1,13 @@
 Feature: Mark all do-what-I-mean
 
-  Background:
+  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))
-
     """
-
-  Scenario: Mark symbols in defun
     When I go to the end of the word "abc"
     And I press "M-f"
     And I press "M-$"
@@ -20,71 +17,22 @@ Feature: Mark all do-what-I-mean
     (defun abc (hmm) (message hmm))
     (defun def (ghi) (message some-other-ghi))
     """
-    When I press "C-g"
-    And I go to the front of the word "hmm"
-    And I press "C-$"
-    And I type "foo"
-    Then I should see:
-    """
-    (defun abc (foo) (message foo))
-    (defun def (ghi) (message some-other-ghi))
-    """
-    
+
   Scenario: Mark all symbols by pressing twice
-    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 some-other-hmm))
-    """
-    When I press "C-g"
-    And I press "M->"
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
     And I insert:
     """
-    (defun def (hmm-hmm) (message hmm))
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message ghi))
     """
-    And I go to the front of the word "hmm"
-    And I press "C-$"
-    And I press "C-$"
-    And I type "humm"
+    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 (humm) (message humm))
-    (defun def (humm) (message some-other-humm))
-    (defun def (humm-humm) (message humm))
-    """
-
-  Scenario: Mark dwim from selection
-    When I press "M-<"
-    And I press "S-M->"
-    And I press "C-$ ghi RET"
-    And I type "xyz"
-    Then I should see:
-    """
-    (defun abc (xyz) (message xyz))
-    (defun def (xyz) (message some-other-xyz))
-    """
-    When I press "C-g"
-    And I go to the front of the word "xyz"
-    And I press "C-M-SPC"
-    And I press "C-$"
-    And I type "foo"
-    Then I should see:
-    """
-    (defun abc (foo) (message foo))
-    (defun def (xyz) (message some-other-xyz))
-    """
-    When I press "C-g"
-    And I press "M-<"
-    And I press "S-M->"
-    And I press "C-u C-$"
-    And I type ";;"
-    Then I should see:
-    """
-    ;;(defun abc (foo) (message foo))
-    ;;(defun def (xyz) (message some-other-xyz))
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message hmm))
     """

features/mark-more.feature

@@ -14,14 +14,6 @@ Feature: Marking multiple parts of the buffer
     And I type "sentence"
     Then I should see "This sentence has the word sentence in it"
 
-  Scenario: Marking next like this, word
-    Given I turn on delete-selection-mode
-    When I insert "This text has the word text in it"
-    And I go to word "text"
-    And I press "C-S-c C->"
-    And I type "sentence"
-    Then I should see "This sentence has the word sentence in it"
-
   Scenario: Skipping a mark
     Given I turn on delete-selection-mode
     When I insert "Here's text, text and text"
@@ -62,14 +54,6 @@ Feature: Marking multiple parts of the buffer
     And I type "sentence"
     Then I should see "This sentence has the word sentence in it"
 
-  Scenario: Marking prev like this, word
-    Given I turn on delete-selection-mode
-    When I insert "This text has the word text in it"
-    And I go to last word "text"
-    And I press "C-S-c C-<"
-    And I type "sentence"
-    Then I should see "This sentence has the word sentence in it"
-
   Scenario: Skipping a prev mark
     Given I turn on delete-selection-mode
     When I insert "Here's text, text and text"

features/multiple-cursors-core.feature

@@ -166,23 +166,9 @@ Feature: Multiple cursors core
     And I press "C-v"
     Then the cursor should be at point "8"
 
-  Scenario: Looping forwards around cursors including one at point-max
-    Given I have cursors at "_" in "1_34_67_"
-    And I press "C-f"
-    And I press "C-v"
-    And I press "C-v"
-    And I press "C-v"
-    Then the cursor should be at point "3"
-
   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"
 
-  Scenario: Looping backwards around cursors including one at point-min
-    Given I have cursors at "_" in "_234_67_9"
-    And I press "M-v"
-    And I press "M-v"
-    And I press "M-v"
-    Then the cursor should be at point "1"

features/repeat-command.feature

@@ -1,37 +0,0 @@
-Feature: Repeat last interactive command for fake cursors (mc/repeat-command)
-
-  Scenario: Clone insert-char from M-x
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I start an action chain
-    When I press "M-x"
-    And I type "insert-char"
-    And I press "RET"
-    And I type "21"
-    And I press "RET"
-    And I press "C-:"
-    And I press "y"
-    And I execute the action chain
-    Then I should see "This !text contains the word !text thrice (!text)"
-
-  Scenario: Clone insert-char from M-:
-    Given I have cursors at "text" in "This text contains the word text thrice (text)"
-    When I start an action chain
-    When I press "M-:"
-    And I type "(insert-char (+ 40 2))"
-    And I press "RET"
-    And I press "C-:"
-    And I press "y"
-    And I execute the action chain
-    Then I should see "This *text contains the word *text thrice (*text)"
-
-  Scenario: Disable prompt
-    Given I have cursors at "text" in "This text/0000 contains the word text/1111 thrice (text/2222)"
-    When I set mc/always-repeat-command to t
-    When I start an action chain
-    And I press "M-x"
-    And I type "zap-to-char"
-    And I press "RET"
-    And I press "/"
-    And I press "C-:"
-    And I execute the action chain
-    Then I should see "This 0000 contains the word 1111 thrice (2222)"

features/step-definitions/multiple-cursors-steps.el

@@ -1,23 +1,9 @@
-;; -*- lexical-binding: t -*-
-
 (When "^I mark next like this$"
       (lambda () (call-interactively 'mc/mark-next-like-this)))
 
-(When "^I mark next like this word$"
-      (lambda () (call-interactively 'mc/mark-next-like-this-word)))
-
-(When "^I mark next like this symbol$"
-      (lambda () (call-interactively 'mc/mark-next-like-this-symbol)))
-
 (When "^I mark previous like this$"
       (lambda () (call-interactively 'mc/mark-previous-like-this)))
 
-(When "^I mark previous like this word$"
-      (lambda () (call-interactively 'mc/mark-previous-like-this-word)))
-
-(When "^I mark previous like this symbol$"
-      (lambda () (call-interactively 'mc/mark-previous-like-this-symbol)))
-
 (When "^I mark all like this$"
       (lambda () (call-interactively 'mc/mark-all-like-this)))
 
@@ -30,9 +16,6 @@
 (When "^I insert numbers$"
       (lambda () (call-interactively 'mc/insert-numbers)))
 
-(When "^I insert letters$"
-      (lambda () (call-interactively 'mc/insert-letters)))
-
 (When "^I reverse regions$"
       (lambda () (call-interactively 'mc/reverse-regions)))
 
@@ -56,25 +39,25 @@
 (Then "^I should have \\([0-9]+\\) cursors$"
       (lambda (num)
         (let ((actual (mc/num-cursors)))
-          (cl-assert (eq (string-to-number num) actual) nil
-                     "Expected to have %s cursors, but was %d." num actual))))
+          (assert (eq (string-to-number num) actual) nil
+                  "Expected to have %s cursors, but was %d." num actual))))
 
 (Then "^I should have one cursor$"
       (lambda ()
-        (cl-assert (not multiple-cursors-mode) nil
-                   "Expected to have one cursor, but multiple-cursors-mode is still active.")
-        (cl-assert (eq 1 (mc/num-cursors)) nil
-                   "Expected to have one cursor, but there are still fake cursor overlays.")))
+        (assert (not multiple-cursors-mode) nil
+                "Expected to have one cursor, but multiple-cursors-mode is still active.")
+        (assert (eq 1 (mc/num-cursors)) nil
+                "Expected to have one cursor, but there are still fake cursor overlays.")))
 
 (Then "^rectangular-region-mode should be off$"
-      (lambda ()
-        (cl-assert (not rectangular-region-mode) nil
-                   "Expected rectangular-region-mode mode to be off, but wasn't.")))
+       (lambda ()
+         (assert (not rectangular-region-mode) nil
+                 "Expected rectangular-region-mode mode to be off, but wasn't.")))
 
 (Then "^rectangular-region-mode should be on$"
-      (lambda ()
-        (cl-assert rectangular-region-mode nil
-                   "Expected rectangular-region-mode mode to be on, but wasn't.")))
+       (lambda ()
+         (assert rectangular-region-mode nil
+                 "Expected rectangular-region-mode mode to be on, but wasn't.")))
 
 (When "^I press \"\\(.+\\)\"$"
       (lambda (keybinding)
@@ -96,35 +79,28 @@
          (mc/mark-all-like-this)
          (mc/keyboard-quit)))
 
-(Given "^I have cursors at \"\\(.+\\)\" in \\(?: \"\\(.+\\)\"\\|:\\)$"
-       (lambda (needle haystack)
-         (insert haystack)
-         (goto-char (point-min))
-         (search-forward needle)
-         (set-mark (point))
-         (goto-char (match-beginning 0))
-         (mc/mark-all-like-this)
-         (mc/keyboard-quit)))
-
-
 (When "^I copy \"\\(.+\\)\" in another program$"
-      (lambda (text)
-        (setq interprogram-paste-function
-              #'(lambda () (let ((r text)) (setq text nil) r)))))
+       (lambda (text)
+         (lexical-let ((text text))
+           (setq interprogram-paste-function
+                 #'(lambda () (let ((r text)) (setq text nil) r))))))
 
 (Given "^I have bound C-! to a lambda that inserts \"\\(.+\\)\"$"
        (lambda (ins)
-         (global-set-key (kbd "C-!") #'(lambda () (interactive) (insert ins)))))
+         (lexical-let ((ins ins))
+           (global-set-key (kbd "C-!") #'(lambda () (interactive) (insert ins))))))
 
 (Given "^I have bound C-! to a new command that inserts \"\\(.+\\)\"$"
        (lambda (ins)
-         (defun mc-test-temp-command () (interactive) (insert ins))
-         (global-set-key (kbd "C-!") 'mc-test-temp-command)))
+         (lexical-let ((ins ins))
+           (defun mc-test-temp-command () (interactive) (insert ins))
+           (global-set-key (kbd "C-!") 'mc-test-temp-command))))
 
 (Given "^I have bound C-! to another new command that inserts \"\\(.+\\)\"$"
        (lambda (ins)
-         (defun mc-test-temp-command-2 () (interactive) (insert ins))
-         (global-set-key (kbd "C-!") 'mc-test-temp-command-2)))
+         (lexical-let ((ins ins))
+           (defun mc-test-temp-command-2 () (interactive) (insert ins))
+           (global-set-key (kbd "C-!") 'mc-test-temp-command-2))))
 
 (Given "^I have bound C-! to a keyboard macro that insert \"_\"$"
        (lambda ()
@@ -136,27 +112,21 @@
         (goto-char (point-min))
         (let ((search (re-search-forward (format "%s" char) nil t))
               (message "Can not go to character '%s' since it does not exist in the current buffer: %s"))
-          (cl-assert search nil message char (espuds-buffer-contents)))))
+          (assert search nil message char (espuds-buffer-contents)))))
 
 (When "^I go to the \\(front\\|end\\) of the word \"\\(.+\\)\"$"
       (lambda (pos word)
         (goto-char (point-min))
         (let ((search (re-search-forward (format "%s" word) nil t))
               (message "Can not go to character '%s' since it does not exist in the current buffer: %s"))
-          (cl-assert search nil message word (espuds-buffer-contents))
+          (assert search nil message word (espuds-buffer-contents))
           (if (string-equal "front" pos) (backward-word)))))
 
-(When "^I go to last word \"\\(.+\\)\"$"
-      (lambda (text)
-        (goto-char (point-max))
-        (let ((search (re-search-backward text nil t)))
-          (cl-assert search nil "The text '%s' was not found in the current buffer." text))))
-
 (When "^I select the last \"\\(.+\\)\"$"
       (lambda (text)
         (goto-char (point-max))
         (let ((search (re-search-backward text nil t)))
-          (cl-assert search nil "The text '%s' was not found in the current buffer." text))
+          (assert search nil "The text '%s' was not found in the current buffer." text))
         (set-mark (point))
         (re-search-forward text)))
 
@@ -167,24 +137,3 @@
                                               (split-string rest))
                                        "-"))))
           (call-interactively func))))
-
-(Then "^I should see exactly\\(?: \"\\(.+\\)\"\\|:\\)$"
-      "Asserts that the current buffer does not include some text with
-       respect of text hidden by overlays"
-      (lambda (expected)
-        (let ((p (point-min))
-              (visible-text "")
-              (message "Expected '%s' to be part of '%s', but was not found in current buffer.")
-              )
-          (while (not (= p (point-max)))
-            (if (not (invisible-p p))
-                (setq visible-text (concat visible-text  (buffer-substring p (1+ p))))
-              )
-            (setq p (1+ p))
-            )
-          (cl-assert (s-equals? expected visible-text) nil message expected visible-text))))
-
-
-;; Local Variables:
-;; byte-compile-warnings: (not cl-functions)
-;; End:

features/support/env.el

@@ -21,17 +21,11 @@
  (multiple-cursors-mode 0)
  (rectangular-region-mode 0)
  (global-set-key (kbd "C->") 'mc/mark-next-like-this)
- (global-set-key (kbd "C-S-c C->") 'mc/mark-next-like-this-word)
- (global-set-key (kbd "C-S-c M->") 'mc/mark-next-like-this-symbol)
  (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
- (global-set-key (kbd "C-S-c C-<") 'mc/mark-previous-like-this-word)
- (global-set-key (kbd "C-S-c M-<") 'mc/mark-previous-like-this-symbol)
  (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 "C-$") 'mc/mark-all-dwim)
  (global-set-key (kbd "M-#") 'mc/mark-all-in-region)
  (global-set-key (kbd "H-0") 'mc/insert-numbers)
- (global-set-key (kbd "H-3") 'mc/insert-letters)
  (global-set-key (kbd "H-1") 'mc/reverse-regions)
  (global-set-key (kbd "H-2") 'mc/sort-regions)
  (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)

features/vertical-align.feature

@@ -1,27 +0,0 @@
-Feature: Align cursors with whitespaces
-    
-  Scenario: Vertical aligning with `x'
-    Given I have cursors at "word" in :
-    """
-    One word
-    Another word
-    """
-    And I press "<<mc/vertical-align>> \170"
-    Then I should see:
-    """
-    One xxxxword
-    Another word
-    """
-
-  Scenario: Vertical aligning with space
-    Given I have cursors at "word" in :
-    """
-    One word
-    Another word
-    """
-    And I press "<<mc/vertical-align-with-space>>"
-    Then I should see:
-    """
-    One     word
-    Another word
-    """

mc-cycle-cursors.el

@@ -1,6 +1,6 @@
 ;;; mc-cycle-cursors.el
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -28,9 +28,11 @@
 
 (require 'multiple-cursors-core)
 
+(eval-when-compile (require 'cl))
+
 (defun mc/next-fake-cursor-after-point ()
   (let ((pos (point))
-        (next-pos (1+ (point-max)))
+        (next-pos (point-max))
         next)
     (mc/for-each-fake-cursor
      (let ((cursor-pos (overlay-get cursor 'point)))
@@ -42,7 +44,7 @@
 
 (defun mc/prev-fake-cursor-before-point ()
   (let ((pos (point))
-        (prev-pos (1- (point-min)))
+        (prev-pos (point-min))
         prev)
     (mc/for-each-fake-cursor
      (let ((cursor-pos (overlay-get cursor 'point)))
@@ -61,7 +63,7 @@
   :group 'multiple-cursors)
 
 (defun mc/handle-loop-condition (error-message)
-  (cl-ecase mc/cycle-looping-behaviour
+  (ecase mc/cycle-looping-behaviour
     (error (error error-message))
     (warn  (message error-message))
     (continue 'continue)
@@ -70,25 +72,25 @@
 (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 (cl-remove-if (lambda (cursor)
-                                              (< (mc/cursor-beg cursor) point))
-                                            cursors))
-         (cursors-in-order (cl-sort cursors-after-point '< :key 'mc/cursor-beg)))
-    (car cursors-in-order)))
+         (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 (cl-remove-if (lambda (cursor)
-                                               (> (mc/cursor-end cursor) point))
-                                             cursors))
-         (cursors-in-order (cl-sort cursors-before-point '> :key 'mc/cursor-end)))
-    (car cursors-in-order)))
+         (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)))
 
-(cl-defun mc/cycle (next-cursor fallback-cursor loop-message)
+(defun* mc/cycle (next-cursor fallback-cursor loop-message)
   (when (null next-cursor)
     (when (eql 'stop (mc/handle-loop-condition loop-message))
-      (cl-return-from mc/cycle nil))
+      (return-from mc/cycle nil))
     (setf next-cursor fallback-cursor))
   (mc/create-fake-cursor-at-point)
   (mc/pop-state-from-overlay next-cursor)
@@ -114,6 +116,7 @@
 
 ;; Local Variables:
 ;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
 ;; End:
 
 ;;; mc-cycle-cursors.el ends here

mc-edit-lines.el

@@ -1,6 +1,6 @@
 ;;; mc-edit-lines.el
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -29,65 +29,26 @@
 
 (require 'multiple-cursors-core)
 
-(defcustom mc/edit-lines-empty-lines nil
-  "What should be done by `mc/edit-lines' when a line is not long enough."
-  :type '(radio (const :tag "Pad the line with spaces." pad)
-                (const :tag "Ignore the line." ignore)
-                (const :tag "Signal an error." error)
-                (const :tag "Nothing.  Cursor is at end of line." nil))
-  :group 'multiple-cursors)
-
 ;;;###autoload
-(defun mc/edit-lines (&optional arg)
+(defun mc/edit-lines ()
   "Add one cursor to each line of the active region.
 Starts from mark and moves in straight down or up towards the
-line point is on.
-
-What is done with lines which are not long enough is governed by
-`mc/edit-lines-empty-lines'.  The prefix argument ARG can be used
-to override this.  If ARG is a symbol (when called from Lisp),
-that symbol is used instead of `mc/edit-lines-empty-lines'.
-Otherwise, if ARG negative, short lines will be ignored.  Any
-other non-nil value will cause short lines to be padded."
-  (interactive "P")
+line point is on."
+  (interactive)
   (when (not (and mark-active (/= (point) (mark))))
-    (error "Mark a set of lines first"))
+    (error "Mark a set of lines first."))
   (mc/remove-fake-cursors)
   (let* ((col (current-column))
-         (point-line (mc/line-number-at-pos))
-         (mark-line (progn (exchange-point-and-mark) (mc/line-number-at-pos)))
-         (direction (if (< point-line mark-line) :up :down))
-         (style (cond
-                 ;; called from lisp
-                 ((and arg (symbolp arg))
-                  arg)
-                 ;; negative argument
-                 ((< (prefix-numeric-value arg) 0)
-                  'ignore)
-                 (arg 'pad)
-                 (t mc/edit-lines-empty-lines))))
+         (point-line (line-number-at-pos))
+         (mark-line (progn (exchange-point-and-mark) (line-number-at-pos)))
+         (direction (if (< point-line mark-line) :up :down)))
     (deactivate-mark)
     (when (and (eq direction :up) (bolp))
-      (previous-logical-line 1 nil)
+      (forward-line -1)
       (move-to-column col))
-    ;; Add the cursors
-    (while (not (eq (mc/line-number-at-pos) point-line))
-      ;; Pad the line
-      (when (eq style 'pad)
-        (while (< (current-column) col)
-          (insert " ")))
-      ;; Error
-      (when (and (eq style 'error)
-                 (not (equal col (current-column))))
-        (error "Short line encountered in `mc/edit-lines'"))
-      ;; create the cursor
-      (unless (and (eq style 'ignore)
-                   (not (equal col (current-column))))
-        (mc/create-fake-cursor-at-point))
-      ;; proceed to next
-      (if (eq direction :up)
-          (previous-logical-line 1 nil)
-        (next-logical-line 1 nil))
+    (while (not (eq (line-number-at-pos) point-line))
+      (mc/create-fake-cursor-at-point)
+      (if (eq direction :up) (forward-line -1) (forward-line 1))
       (move-to-column col))
     (multiple-cursors-mode)))
 

mc-hide-unmatched-lines-mode.el

@@ -1,108 +0,0 @@
-;;; mc-hide-unmatched-lines-mode.el
-
-;; Copyright (C) 2014 Aleksey Fedotov
-
-;; Author: Aleksey Fedotov <lexa@cfotr.com>
-;; Keywords: editing cursors
-
-;; 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 of the License, 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 this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This minor mode when enabled hides all lines where no cursors (and
-;; also hum/lines-to-expand below and above) To make use of this mode
-;; press "C-'" while multiple-cursor-mode is active. You can still
-;; edit lines while you are in mc-hide-unmatched-lines mode. To leave
-;; this mode press "<return>" or "C-g"
-;;
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-(require 'mc-mark-more)
-
-(defvar hum/hide-unmatched-lines-mode-map (make-sparse-keymap)
-  "Keymap for hide unmatched lines is mainly for rebinding C-g")
-
-(define-key hum/hide-unmatched-lines-mode-map (kbd "C-g") 'hum/keyboard-quit)
-(define-key hum/hide-unmatched-lines-mode-map (kbd "<return>") 'hum/keyboard-quit)
-
-(defun hum/keyboard-quit ()
-  "Leave hide-unmatched-lines mode"
-  (interactive)
-  (mc-hide-unmatched-lines-mode 0))
-
-;; used only in in multiple-cursors-mode-disabled-hook
-(defun hum/disable-hum-mode ()
-  (mc-hide-unmatched-lines-mode 0))
-
-;;;###autoload
-(define-minor-mode mc-hide-unmatched-lines-mode
-  "Minor mode when enabled hides all lines where no cursors (and
-also hum/lines-to-expand below and above) To make use of this
-mode press \"C-'\" while multiple-cursor-mode is active. You can
-still edit lines while you are in mc-hide-unmatched-lines
-mode. To leave this mode press <return> or \"C-g\""
-  nil " hu"
-  hum/hide-unmatched-lines-mode-map
-  (if mc-hide-unmatched-lines-mode
-      ;;just in case if mc mode will be disabled while hide-unmatched-lines is active
-      (progn
-        (hum/hide-unmatched-lines)
-        (add-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode t t))
-    (progn
-      (hum/unhide-unmatched-lines)
-      (remove-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode))))
-
-(defconst hum/invisible-overlay-name 'hum/invisible-overlay-name)
-
-(defcustom hum/lines-to-expand 2
-  "How many lines below and above cursor to show"
-  :type '(integer)
-  :group 'multiple-cursors)
-
-(defcustom hum/placeholder "..."
-  "Placeholder which will be placed instead of hidden text"
-  :type '(string)
-  :group 'multiple-cursors)
-
-(defun hum/add-invisible-overlay (begin end)
-  (let ((overlay (make-overlay begin
-                               end
-                               (current-buffer)
-                               t
-                               nil
-                               )))
-    (overlay-put overlay hum/invisible-overlay-name t)
-    (overlay-put overlay 'invisible t)
-    (overlay-put overlay 'intangible t)
-    (overlay-put overlay 'evaporate t)
-    (overlay-put overlay 'after-string hum/placeholder)))
-
-(defun hum/hide-unmatched-lines ()
-  (let ((begin (point-min)))
-    (mc/for-each-cursor-ordered
-     (save-excursion
-       (goto-char (mc/cursor-beg cursor))
-       (if (< begin (line-beginning-position (- hum/lines-to-expand)))
-           (hum/add-invisible-overlay begin (line-end-position (- hum/lines-to-expand))))
-       (setq begin (line-beginning-position (+ 2 hum/lines-to-expand)))))
-    (hum/add-invisible-overlay begin (point-max))))
-
-(defun hum/unhide-unmatched-lines ()
-  (remove-overlays nil nil hum/invisible-overlay-name t))
-
-(define-key mc/keymap (kbd "C-'") 'mc-hide-unmatched-lines-mode)
-
-(provide 'mc-hide-unmatched-lines-mode)

mc-mark-more.el

@@ -1,6 +1,6 @@
 ;;; mc-mark-more.el
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -55,7 +55,7 @@
     beg))
 
 (defun mc/furthest-cursor-before-point ()
-  (let ((beg (if mark-active (min (mark) (point)) (point)))
+  (let ((beg (min (mark) (point)))
         furthest)
     (mc/for-each-fake-cursor
      (when (< (mc/cursor-beg cursor) beg)
@@ -64,7 +64,7 @@
     furthest))
 
 (defun mc/furthest-cursor-after-point ()
-  (let ((end (if mark-active (max (mark) (point)) (point)))
+  (let ((end (max (mark) (point)))
         furthest)
     (mc/for-each-fake-cursor
      (when (> (mc/cursor-end cursor) end)
@@ -72,18 +72,6 @@
        (setq furthest cursor)))
     furthest))
 
-(defun mc/fake-cursor-at-point (&optional point)
-  "Return the fake cursor with its point right at POINT (defaults
-to (point)), or nil."
-  (setq point (or point (point)))
-  (let ((cursors (mc/all-fake-cursors))
-        (c nil))
-    (catch 'found
-      (while (setq c (pop cursors))
-        (when (eq (marker-position (overlay-get c 'point))
-                  point)
-          (throw 'found c))))))
-
 (defun mc/region-strings ()
   (let ((strings (list (buffer-substring-no-properties (point) (mark)))))
     (mc/for-each-fake-cursor
@@ -104,106 +92,54 @@ 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 (cl-ecase direction
+        (point-out-of-order (ecase direction
                               (forwards       (< (point) (mark)))
                               (backwards (not (< (point) (mark))))))
-        (furthest-cursor (cl-ecase direction
+        (furthest-cursor (ecase direction
                            (forwards  (mc/furthest-cursor-after-point))
                            (backwards (mc/furthest-cursor-before-point))))
-        (start-char (cl-ecase direction
+        (start-char (ecase direction
                       (forwards  (mc/furthest-region-end))
                       (backwards (mc/first-region-start))))
-        (search-function (cl-ecase direction
+        (search-function (ecase direction
                            (forwards  'search-forward-regexp)
                            (backwards 'search-backward-regexp)))
-        (match-point-getter (cl-ecase direction
+        (match-point-getter (ecase direction
                               (forwards 'match-beginning)
                               (backwards 'match-end))))
-    (if (and skip-last (not furthest-cursor))
-        (error "No cursors to be skipped")
-      (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))
-         (user-error "no more matches found."))))))
+    (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
-If no region is active add a cursor on the next line
 With negative ARG, delete the last one instead.
 With zero ARG, skip the last one and mark next."
   (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc/mark-lines arg 'forwards)))
+  (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-like-this-word (arg)
-  "Find and mark the next part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc--select-thing-at-point 'word)
-      (mc/mark-more-like-this (= arg 0) 'forwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun mc/mark-next-like-this-symbol (arg)
-  "Find and mark the next part of the buffer matching the currently active region
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc--select-thing-at-point 'symbol)
-      (mc/mark-more-like-this (= arg 0) 'forwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-
 ;;;###autoload
 (defun mc/mark-next-word-like-this (arg)
-  "Find and mark the next word of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active add a cursor on the next line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
   (interactive "p")
   (let ((mc/enclose-search-term 'words))
     (mc/mark-next-like-this arg)))
 
 ;;;###autoload
 (defun mc/mark-next-symbol-like-this (arg)
-  "Find and mark the next symbol of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active add a cursor on the next line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
   (interactive "p")
   (let ((mc/enclose-search-term 'symbols))
     (mc/mark-next-like-this arg)))
@@ -211,92 +147,36 @@ With zero ARG, skip the last one and mark next."
 ;;;###autoload
 (defun mc/mark-previous-like-this (arg)
   "Find and mark the previous part of the buffer matching the currently active region
-If no region is active add a cursor on the previous line
 With negative ARG, delete the last one instead.
 With zero ARG, skip the last one and mark next."
   (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-before-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc/mark-lines arg 'backwards)))
+  (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-like-this-word (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the previous match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark previous."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc--select-thing-at-point 'word)
-      (mc/mark-more-like-this (= arg 0) 'backwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun mc/mark-previous-like-this-symbol (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-If no region is active, mark the symbol at the point and find the previous match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark previous."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc--select-thing-at-point 'symbol)
-      (mc/mark-more-like-this (= arg 0) 'backwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-
 ;;;###autoload
 (defun mc/mark-previous-word-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
   (interactive "p")
   (let ((mc/enclose-search-term 'words))
     (mc/mark-previous-like-this arg)))
 
 ;;;###autoload
 (defun mc/mark-previous-symbol-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
   (interactive "p")
   (let ((mc/enclose-search-term 'symbols))
     (mc/mark-previous-like-this arg)))
 
 (defun mc/mark-lines (num-lines direction)
-  (dotimes (i (if (= num-lines 0) 1 num-lines))
-    (mc/save-excursion
-     (let ((furthest-cursor (cl-ecase direction
-                              (forwards  (mc/furthest-cursor-after-point))
-                              (backwards (mc/furthest-cursor-before-point)))))
-       (when (overlayp furthest-cursor)
-         (goto-char (overlay-get furthest-cursor 'point))
-         (when (= num-lines 0)
-           (mc/remove-fake-cursor furthest-cursor))))
-     (cl-ecase direction
-       (forwards (next-logical-line 1 nil))
-       (backwards (previous-logical-line 1 nil)))
-     (mc/create-fake-cursor-at-point))))
+  (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)
@@ -383,53 +263,23 @@ With zero ARG, skip the last one and mark next."
     (mc/mark-all-like-this)))
 
 ;;;###autoload
-(defun mc/mark-all-in-region (beg end &optional search)
+(defun mc/mark-all-in-region (beg end)
   "Find and mark all the parts in the region matching the given search"
   (interactive "r")
-  (let ((search (or search (read-from-minibuffer "Mark all in region: ")))
+  (let ((search (read-from-minibuffer "Mark all in region: "))
         (case-fold-search nil))
-    (if (string= search "")
-        (message "Mark aborted")
-      (progn
-        (mc/remove-fake-cursors)
-        (goto-char beg)
-        (while (search-forward search end t)
-          (push-mark (match-beginning 0))
-          (mc/create-fake-cursor-at-point))
-        (let ((first (mc/furthest-cursor-before-point)))
-          (if (not first)
-              (error "Search failed for %S" search)
-            (mc/pop-state-from-overlay first)))
-        (if (> (mc/num-cursors) 1)
-            (multiple-cursors-mode 1)
-          (multiple-cursors-mode 0))))))
-
-;;;###autoload
-(defun mc/mark-all-in-region-regexp (beg end)
-  "Find and mark all the parts in the region matching the given regexp."
-  (interactive "r")
-  (let ((search (read-regexp "Mark regexp in region: "))
-        (case-fold-search nil))
-    (if (string= search "")
-        (message "Mark aborted")
-      (progn
-        (mc/remove-fake-cursors)
-        (goto-char beg)
-        (let ((lastmatch))
-          (while (and (< (point) end) ; can happen because of (forward-char)
-                      (search-forward-regexp search end t))
-            (push-mark (match-beginning 0))
-            (mc/create-fake-cursor-at-point)
-            (setq lastmatch (point))
-            (when (= (point) (match-beginning 0))
-              (forward-char)))
-          (unless lastmatch
-            (error "Search failed for %S" search)))
-        (goto-char (match-end 0))
-        (if (< (mc/num-cursors) 3)
-            (multiple-cursors-mode 0)
-          (mc/pop-state-from-overlay (mc/furthest-cursor-before-point))
-          (multiple-cursors-mode 1))))))
+    (mc/remove-fake-cursors)
+    (goto-char beg)
+    (while (search-forward search end t)
+      (push-mark (match-beginning 0))
+      (mc/create-fake-cursor-at-point))
+    (let ((first (mc/furthest-cursor-before-point)))
+      (if (not first)
+          (error "Search failed for %S" search)
+        (mc/pop-state-from-overlay first))))
+  (if (> (mc/num-cursors) 1)
+      (multiple-cursors-mode 1)
+    (multiple-cursors-mode 0)))
 
 (when (not (fboundp 'set-temporary-overlay-map))
   ;; Backport this function from newer emacs versions
@@ -566,28 +416,6 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
         (when (<= (mc/num-cursors) before)
           (mc/mark-all-like-this))))))
 
-;;;###autoload
-(defun mc/mark-all-dwim (arg)
-  "Tries even harder to guess what you want to mark all of.
-
-If the region is active and spans multiple lines, it will behave
-as if `mc/mark-all-in-region'. With the prefix ARG, it will call
-`mc/edit-lines' instead.
-
-If the region is inactive or on a single line, it will behave like
-`mc/mark-all-like-this-dwim'."
-  (interactive "P")
-  (if (and (use-region-p)
-           (not (> (mc/num-cursors) 1))
-           (not (= (mc/line-number-at-pos (region-beginning))
-                   (mc/line-number-at-pos (region-end)))))
-      (if arg
-          (call-interactively 'mc/edit-lines)
-        (call-interactively 'mc/mark-all-in-region))
-    (progn
-      (setq this-command 'mc/mark-all-like-this-dwim)
-      (mc/mark-all-like-this-dwim arg))))
-
 (defun mc--in-defun ()
   (bounds-of-thing-at-point 'defun))
 
@@ -652,9 +480,8 @@ If the region is inactive or on a single line, it will behave like
          (<= (point) end))))
 
 ;;;###autoload
-(defun mc/toggle-cursor-on-click (event)
-  "Add a cursor where you click, or remove a fake cursor that is
-already there."
+(defun mc/add-cursor-on-click (event)
+  "Add a cursor where you click."
   (interactive "e")
   (mouse-minibuffer-check event)
   ;; Use event-end in case called from mouse-drag-region.
@@ -663,20 +490,12 @@ already there."
     (if (not (windowp (posn-window position)))
         (error "Position not in text area of window"))
     (select-window (posn-window position))
-    (let ((pt (posn-point position)))
-      (if (numberp pt)
-          ;; is there a fake cursor with the actual *point* right where we are?
-          (let ((existing (mc/fake-cursor-at-point pt)))
-            (if existing
-                (mc/remove-fake-cursor existing)
-              (save-excursion
-                (goto-char pt)
-                (mc/create-fake-cursor-at-point))))))
+    (if (numberp (posn-point position))
+        (save-excursion
+          (goto-char (posn-point position))
+          (mc/create-fake-cursor-at-point)))
     (mc/maybe-multiple-cursors-mode)))
 
-;;;###autoload
-(defalias 'mc/add-cursor-on-click 'mc/toggle-cursor-on-click)
-
 ;;;###autoload
 (defun mc/mark-sgml-tag-pair ()
   "Mark the tag we're in and its pair for renaming."

mc-mark-pop.el

@@ -4,8 +4,9 @@
 
 ;;;###autoload
 (defun mc/mark-pop ()
-  "Add a cursor at the current point, pop off mark ring and jump
-to the popped mark."
+  "Add one cursor to each line of the active region.
+Starts from mark and moves in straight down or up towards the
+line point is on."
   (interactive)
   ;; If the mark happens to be at the current point, just pop that one off.
   (while (eql (mark) (point))

mc-separate-operations.el

@@ -1,6 +1,6 @@
 ;;; mc-separate-operations.el - functions that work differently on each cursor
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -29,24 +29,16 @@
 
 (require 'multiple-cursors-core)
 
-(defcustom mc/insert-numbers-default 0
-  "The default number at which to start counting for
-`mc/insert-numbers'"
-  :type 'integer
-  :group 'multiple-cursors)
-
-(defvar mc--insert-numbers-number 0)
-
 ;;;###autoload
 (defun mc/insert-numbers (arg)
-  "Insert increasing numbers for each cursor, starting at
-`mc/insert-numbers-default' or ARG."
+  "Insert increasing numbers for each cursor, starting at 0 or ARG."
   (interactive "P")
-  (setq mc--insert-numbers-number (or (and arg (prefix-numeric-value arg))
-                                      mc/insert-numbers-default))
+  (setq mc--insert-numbers-number (or arg 0))
   (mc/for-each-cursor-ordered
    (mc/execute-command-for-fake-cursor 'mc--insert-number-and-increase cursor)))
 
+(defvar mc--insert-numbers-number 0)
+
 (defun mc--insert-number-and-increase ()
   (interactive)
   (insert (number-to-string mc--insert-numbers-number))
@@ -61,32 +53,6 @@
                             (mc/cursor-end cursor)) strings))))
     (nreverse strings)))
 
-(defvar mc--insert-letters-number 0)
-
-;;;###autoload
-(defun mc/insert-letters (arg)
-  "Insert increasing letters for each cursor, starting at 0 or ARG.
-     Where letter[0]=a letter[2]=c letter[26]=aa"
-  (interactive "P")
-  (setq mc--insert-letters-number (or (and arg (prefix-numeric-value arg))
-                                      0))
-  (mc/for-each-cursor-ordered
-   (mc/execute-command-for-fake-cursor 'mc--insert-letter-and-increase cursor)))
-
-(defun mc--number-to-letters (number)
-  (let ((letter
-         (char-to-string
-          (+ (mod number 26) ?a)))
-        (number2 (/ number 26)))
-    (if (> number2 0)
-        (concat (mc--number-to-letters (- number2 1)) letter)
-      letter)))
-
-(defun mc--insert-letter-and-increase ()
-  (interactive)
-  (insert (mc--number-to-letters mc--insert-letters-number))
-  (setq mc--insert-letters-number (1+ mc--insert-letters-number)))
-
 (defvar mc--strings-to-replace nil)
 
 (defun mc--replace-region-strings-1 ()
@@ -120,31 +86,5 @@
   (setq mc--strings-to-replace (sort (mc--ordered-region-strings) 'string<))
   (mc--replace-region-strings))
 
-
-;;;###autoload
-(defun mc/vertical-align (character)
-  "Aligns all cursors vertically with a given CHARACTER to the one with the
-highest column number (the rightest).
-Might not behave as intended if more than one cursors are on the same line."
-  (interactive "c")
-  (let ((rightest-column (current-column)))
-    (mc/execute-command-for-all-cursors
-     (lambda () "get the rightest cursor"
-       (interactive)
-       (setq rightest-column (max (current-column) rightest-column))
-       ))
-    (mc/execute-command-for-all-cursors
-     (lambda ()
-       (interactive)
-       (let ((missing-spaces (- rightest-column (current-column))))
-         (save-excursion (insert (make-string missing-spaces character)))
-         (forward-char missing-spaces))))))
-
-;;;###autoload
-(defun mc/vertical-align-with-space ()
-  "Aligns all cursors with whitespace like `mc/vertical-align' does"
-  (interactive)
-  (mc/vertical-align 32))
-
 (provide 'mc-separate-operations)
 ;;; mc-separate-operations.el ends here

multiple-cursors-core.el

@@ -1,6 +1,6 @@
 ;;; multiple-cursors-core.el --- An experiment in multiple cursors for emacs.
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -25,21 +25,15 @@
 
 ;;; Code:
 
-(require 'cl-lib)
-(require 'rect)
+(require 'cl)
 
-(defvar mc--read-char)
+(require 'rect)
 
 (defface mc/cursor-face
   '((t (:inverse-video t)))
   "The face used for fake cursors"
   :group 'multiple-cursors)
 
-(defface mc/cursor-bar-face
-  `((t (:height 1 :background ,(face-attribute 'cursor :background))))
-  "The face used for fake cursors if the cursor-type is bar"
-  :group 'multiple-cursors)
-
 (defface mc/region-face
   '((t :inherit region))
   "The face used for fake regions"
@@ -57,9 +51,9 @@
                (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list))))))
 
 (defun mc/all-fake-cursors (&optional start end)
-  (cl-remove-if-not 'mc/fake-cursor-p
-                    (overlays-in (or start (point-min))
-                                 (or end   (point-max)))))
+  (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"
@@ -103,39 +97,16 @@
        (set-marker ,p nil)
        (set-marker ,s nil))))
 
-(defun mc/cursor-is-bar ()
-  "Return non-nil if the cursor is a bar."
-  (or (eq cursor-type 'bar)
-    (and (listp cursor-type)
-         (eq (car cursor-type) 'bar))))
-
-(defun mc/line-number-at-pos (&optional pos absolute)
-  "Faster implementation of `line-number-at-pos'."
-  (if pos
-      (save-excursion
-        (if absolute
-            (save-restriction
-              (widen)
-              (goto-char pos)
-              (string-to-number (format-mode-line "%l")))
-          (goto-char pos)
-          (string-to-number (format-mode-line "%l"))))
-    (string-to-number (format-mode-line "%l"))))
-
 (defun mc/make-cursor-overlay-at-eol (pos)
   "Create overlay to look like cursor at end of line."
   (let ((overlay (make-overlay pos pos nil nil nil)))
-    (if (mc/cursor-is-bar)
-	(overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
-      (overlay-put overlay 'after-string (propertize " " 'face 'mc/cursor-face)))
+    (overlay-put overlay 'after-string (propertize " " 'face 'mc/cursor-face))
     overlay))
 
 (defun mc/make-cursor-overlay-inline (pos)
   "Create overlay to look like cursor inside text."
   (let ((overlay (make-overlay pos (1+ pos) nil nil nil)))
-    (if (mc/cursor-is-bar)
-	(overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
-      (overlay-put overlay 'face 'mc/cursor-face))
+    (overlay-put overlay 'face 'mc/cursor-face)
     overlay))
 
 (defun mc/make-cursor-overlay-at-point ()
@@ -159,29 +130,16 @@ highlights the entire width of the window."
                                   mark-ring
                                   mark-active
                                   yank-undo-function
+                                  kill-ring-yank-pointer
                                   autopair-action
                                   autopair-wrap-action
-                                  temporary-goal-column
-                                  er/history
-                                  dabbrev--abbrev-char-regexp
-                                  dabbrev--check-other-buffers
-                                  dabbrev--friend-buffer-list
-                                  dabbrev--last-abbrev-location
-                                  dabbrev--last-abbreviation
-                                  dabbrev--last-buffer
-                                  dabbrev--last-buffer-found
-                                  dabbrev--last-direction
-                                  dabbrev--last-expansion
-                                  dabbrev--last-expansion-location
-                                  dabbrev--last-table)
+                                  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)))
-  (overlay-put o 'mark (set-marker (make-marker)
-				   (let ((mark-even-if-inactive t))
-				     (mark))))
+  (overlay-put o 'mark (set-marker (make-marker) (mark)))
   (dolist (var mc/cursor-specific-vars)
     (when (boundp var) (overlay-put o var (symbol-value var))))
   o)
@@ -215,39 +173,11 @@ highlights the entire width of the window."
 
 (defun mc/create-cursor-id ()
   "Returns a unique cursor id"
-  (cl-incf mc--current-cursor-id))
-
-(defvar mc--max-cursors-original nil
-  "This variable maintains the original maximum number of cursors.
-When `mc/create-fake-cursor-at-point' is called and
-`mc/max-cursors' is overridden, this value serves as a backup so
-that `mc/max-cursors' can take on a new value.  When
-`mc/remove-fake-cursors' is called, the values are reset.")
-
-(defcustom mc/max-cursors nil
-  "Safety ceiling for the number of active cursors.
-If your emacs slows down or freezes when using too many cursors,
-customize this value appropriately.
-
-Cursors will be added until this value is reached, at which point
-you can either temporarily override the value or abort the
-operation entirely.
-
-If this value is nil, there is no ceiling."
-  :type '(integer)
-  :group 'multiple-cursors)
+  (incf mc--current-cursor-id))
 
 (defun mc/create-fake-cursor-at-point (&optional id)
   "Add a fake cursor and possibly a fake active region overlay based on point and mark.
 Saves the current state in the overlay to be restored later."
-  (unless mc--max-cursors-original
-    (setq mc--max-cursors-original mc/max-cursors))
-  (when mc/max-cursors
-    (unless (< (mc/num-cursors) mc/max-cursors)
-      (if (yes-or-no-p (format "%d active cursors. Continue? " (mc/num-cursors)))
-          (setq mc/max-cursors (read-number "Enter a new, temporary maximum: "))
-        (mc/remove-fake-cursors)
-        (error "Aborted: too many cursors"))))
   (let ((overlay (mc/make-cursor-overlay-at-point)))
     (overlay-put overlay 'mc-id (or id (mc/create-cursor-id)))
     (overlay-put overlay 'type 'fake-cursor)
@@ -301,8 +231,6 @@ cursor with updated info."
 ;; Intercept some reading commands so you won't have to
 ;; answer them for every single cursor
 
-(defvar mc--read-char nil)
-(defvar multiple-cursors-mode nil)
 (defadvice read-char (around mc-support activate)
   (if (not multiple-cursors-mode)
       ad-do-it
@@ -310,7 +238,6 @@ cursor with updated info."
       (setq mc--read-char ad-do-it))
     (setq ad-return-value mc--read-char)))
 
-(defvar mc--read-quoted-char nil)
 (defadvice read-quoted-char (around mc-support activate)
   (if (not multiple-cursors-mode)
       ad-do-it
@@ -330,9 +257,9 @@ cursor with updated info."
 
 (defun mc/cursor-with-id (id)
   "Find the first cursor with the given id, or nil"
-  (cl-find-if #'(lambda (o) (and (mc/fake-cursor-p o)
-                            (= id (overlay-get o 'mc-id))))
-              (overlays-in (point-min) (point-max))))
+  (find-if #'(lambda (o) (and (mc/fake-cursor-p o)
+                              (= id (overlay-get o 'mc-id))))
+           (overlays-in (point-min) (point-max))))
 
 (defvar mc--stored-state-for-undo nil
   "Variable to keep the state of the real cursor while undoing a fake one")
@@ -352,16 +279,6 @@ cursor with updated info."
     (mc/pop-state-from-overlay mc--stored-state-for-undo)
     (setq mc--stored-state-for-undo nil)))
 
-(defcustom mc/always-run-for-all nil
-  "Disables whitelisting and always executes commands for every fake cursor."
-  :type '(boolean)
-  :group 'multiple-cursors)
-
-(defcustom mc/always-repeat-command nil
-  "Disables confirmation for `mc/repeat-command' command."
-  :type '(boolean)
-  :group 'multiple-cursors)
-
 (defun mc/prompt-for-inclusion-in-whitelist (original-command)
   "Asks the user, then adds the command either to the once-list or the all-list."
   (let ((all-p (y-or-n-p (format "Do %S for all cursors?" original-command))))
@@ -373,8 +290,8 @@ cursor with updated info."
 
 (defun mc/num-cursors ()
   "The number of cursors (real and fake) in the buffer."
-  (1+ (cl-count-if 'mc/fake-cursor-p
-                   (overlays-in (point-min) (point-max)))))
+  (1+ (count-if 'mc/fake-cursor-p
+                (overlays-in (point-min) (point-max)))))
 
 (defvar mc--this-command nil
   "Used to store the original command being run.")
@@ -448,15 +365,10 @@ the original cursor, to inform about the lack of support."
                   (message "%S is not supported with multiple cursors%s"
                            original-command
                            (get original-command 'mc--unsupported))
-
-                ;; lazy-load the user's list file
-                (mc/load-lists)
-
                 (when (and original-command
                            (not (memq original-command mc--default-cmds-to-run-once))
                            (not (memq original-command mc/cmds-to-run-once))
-                           (or mc/always-run-for-all
-                               (memq original-command mc--default-cmds-to-run-for-all)
+                           (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))))))))))
@@ -466,10 +378,7 @@ the original cursor, to inform about the lack of support."
 Do not use to conclude editing with multiple cursors. For that
 you should disable multiple-cursors-mode."
   (mc/for-each-fake-cursor
-   (mc/remove-fake-cursor cursor))
-  (when mc--max-cursors-original
-    (setq mc/max-cursors mc--max-cursors-original))
-  (setq mc--max-cursors-original nil))
+   (mc/remove-fake-cursor cursor)))
 
 (defun mc/keyboard-quit ()
   "Deactivate mark if there are any active, otherwise exit multiple-cursors-mode."
@@ -478,17 +387,6 @@ you should disable multiple-cursors-mode."
       (multiple-cursors-mode 0)
     (deactivate-mark)))
 
-(defun mc/repeat-command ()
-  "Run last command from `command-history' for every fake cursor."
-  (interactive)
-  (when (or mc/always-repeat-command
-            (y-or-n-p (format "[mc] repeat complex command: %s? " (caar command-history))))
-    (mc/execute-command-for-all-fake-cursors
-     (lambda () (interactive)
-       (cl-letf (((symbol-function 'read-from-minibuffer)
-                  (lambda (p &optional i k r h d m) (read i))))
-         (repeat-complex-command 0))))))
-
 (defvar mc/keymap nil
   "Keymap while multiple cursors are active.
 Main goal of the keymap is to rebind C-g and <return> to conclude
@@ -497,7 +395,6 @@ multiple cursors editing.")
   (setq mc/keymap (make-sparse-keymap))
   (define-key mc/keymap (kbd "C-g") 'mc/keyboard-quit)
   (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
-  (define-key mc/keymap (kbd "C-:") 'mc/repeat-command)
   (when (fboundp 'phi-search)
     (define-key mc/keymap (kbd "C-s") 'phi-search))
   (when (fboundp 'phi-search-backward)
@@ -523,11 +420,11 @@ The entries are returned in the order they are found in the buffer."
 (defun mc--maybe-set-killed-rectangle ()
   "Add the latest kill-ring entry for each cursor to killed-rectangle.
 So you can paste it in later with `yank-rectangle'."
-  (let ((entries (let (mc/max-cursors) (mc--kill-ring-entries))))
+  (let ((entries (mc--kill-ring-entries)))
     (unless (mc--all-equal entries)
       (setq killed-rectangle entries))))
 
-(defvar mc/unsupported-minor-modes '(company-mode auto-complete-mode flyspell-mode jedi-mode)
+(defvar mc/unsupported-minor-modes '(auto-complete-mode flyspell-mode)
   "List of minor-modes that does not play well with multiple-cursors.
 They are temporarily disabled when multiple-cursors are active.")
 
@@ -558,7 +455,6 @@ They are temporarily disabled when multiple-cursors are active.")
   :group 'multiple-cursors)
 (put 'mc/mode-line 'risky-local-variable t)
 
-;;;###autoload
 (define-minor-mode multiple-cursors-mode
   "Mode while multiple cursors are active."
   nil mc/mode-line mc/keymap
@@ -599,15 +495,14 @@ from being executed if in multiple-cursors-mode."
 (unsupported-cmd isearch-backward ". Feel free to add a compatible version.")
 
 ;; Make sure pastes from other programs are added to all kill-rings when yanking
-(defadvice current-kill (before interprogram-paste-for-all-cursors
-				(n &optional do-not-move) activate)
+(defadvice current-kill (before interprogram-paste-for-all-cursors activate)
   (let ((interprogram-paste (and (= n 0)
                                  interprogram-paste-function
                                  (funcall interprogram-paste-function))))
     (when interprogram-paste
       ;; Add interprogram-paste to normal kill ring, just
       ;; like current-kill usually does for itself.
-      ;; We have to do the work for it though, since the funcall only returns
+      ;; We have to do the work for it tho, since the funcall only returns
       ;; something once. It is not a pure function.
       (let ((interprogram-cut-function nil))
         (if (listp interprogram-paste)
@@ -624,30 +519,19 @@ from being executed if in multiple-cursors-mode."
            (overlay-put cursor 'kill-ring kill-ring)
            (overlay-put cursor 'kill-ring-yank-pointer kill-ring-yank-pointer)))))))
 
-(defcustom mc/list-file (locate-user-emacs-file ".mc-lists.el")
+(defvar mc/list-file "~/.emacs.d/.mc-lists.el"
   "The position of the file that keeps track of your preferences
-for running commands with multiple cursors."
-  :type 'file
-  :group 'multiple-cursors)
-
-(defvar mc--list-file-loaded nil
-  "Whether the list file has already been loaded.")
-
-(defun mc/load-lists ()
-  "Loads preferences for running commands with multiple cursors from `mc/list-file'"
-  (unless mc--list-file-loaded
-    (load mc/list-file 'noerror 'nomessage)
-    (setq mc--list-file-loaded t)))
+for running commands with multiple cursors.")
 
 (defun mc/dump-list (list-symbol)
   "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
-  (cl-symbol-macrolet ((value (symbol-value list-symbol)))
+  (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)))))
+                                                 (symbol-name y)))))
     (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent))
           value)
     (insert "))")
@@ -676,13 +560,9 @@ for running commands with multiple cursors."
                                      mc/edit-ends-of-lines
                                      mc/edit-beginnings-of-lines
                                      mc/mark-next-like-this
-				     mc/mark-next-like-this-word
-				     mc/mark-next-like-this-symbol
                                      mc/mark-next-word-like-this
                                      mc/mark-next-symbol-like-this
                                      mc/mark-previous-like-this
-                                     mc/mark-previous-like-this-word
-                                     mc/mark-previous-like-this-symbol
                                      mc/mark-previous-word-like-this
                                      mc/mark-previous-symbol-like-this
                                      mc/mark-all-like-this
@@ -693,10 +573,8 @@ for running commands with multiple cursors."
                                      mc/mark-all-words-like-this-in-defun
                                      mc/mark-all-symbols-like-this-in-defun
                                      mc/mark-all-like-this-dwim
-                                     mc/mark-all-dwim
                                      mc/mark-sgml-tag-pair
                                      mc/insert-numbers
-				     mc/insert-letters
                                      mc/sort-regions
                                      mc/reverse-regions
                                      mc/cycle-forward
@@ -713,17 +591,11 @@ for running commands with multiple cursors."
                                      mc/skip-to-next-like-this
                                      mc/skip-to-previous-like-this
                                      rrm/switch-to-multiple-cursors
-                                     mc-hide-unmatched-lines-mode
-                                     mc/repeat-command
-                                     hum/keyboard-quit
-                                     hum/unhide-invisible-overlays
                                      save-buffer
                                      ido-exit-minibuffer
-                                     ivy-done
                                      exit-minibuffer
                                      minibuffer-complete-and-exit
                                      execute-extended-command
-                                     eval-expression
                                      undo
                                      redo
                                      undo-tree-undo
@@ -757,8 +629,7 @@ for running commands with multiple cursors."
                                      windmove-left
                                      windmove-right
                                      windmove-up
-                                     windmove-down
-                                     repeat-complex-command))
+                                     windmove-down))
 
 (defvar mc--default-cmds-to-run-for-all nil
   "Default set of commands that should be mirrored by all cursors")
@@ -807,8 +678,6 @@ for running commands with multiple cursors."
                                         py-electric-backspace
                                         c-electric-backspace
                                         org-delete-backward-char
-                                        cperl-electric-backspace
-                                        python-indent-dedent-line-backspace
                                         paredit-backward-delete
                                         autopair-backspace
                                         just-one-space
@@ -818,7 +687,6 @@ for running commands with multiple cursors."
                                         exchange-point-and-mark
                                         cua-set-mark
                                         cua-replace-region
-                                        cua-delete-region
                                         move-end-of-line
                                         beginning-of-line
                                         move-beginning-of-line
@@ -843,12 +711,13 @@ for running commands with multiple cursors."
 (defvar mc/cmds-to-run-for-all nil
   "Commands to run for all cursors in multiple-cursors-mode")
 
+(load mc/list-file t) ;; load, but no errors if it does not exist yet please
+
 (provide 'multiple-cursors-core)
-(require 'mc-cycle-cursors)
-(require 'mc-hide-unmatched-lines-mode)
 
 ;; Local Variables:
 ;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
 ;; End:
 
 ;;; multiple-cursors-core.el ends here

multiple-cursors-pkg.el

@@ -1,3 +1,2 @@
-(define-package "multiple-cursors" "1.3.0"
-  "Multiple cursors for Emacs."
-  '((cl-lib "0.5")))
+(define-package "multiple-cursors" "1.2.3"
+                "Multiple cursors for Emacs.")

multiple-cursors.el

@@ -1,9 +1,9 @@
 ;;; multiple-cursors.el --- Multiple cursors for emacs.
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012-2013 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
-;; Version: 1.4.0
+;; Version: 1.2.2
 ;; Keywords: editing cursors
 
 ;; This program is free software; you can redistribute it and/or modify
@@ -22,7 +22,7 @@
 ;;; Commentary:
 
 ;; Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
-;; there are kinks. Don't be afraid though, I've been using it since 2011 with
+;; there are kinks. Don't be afraid tho, I've been using it since 2011 with
 ;; great success and much merriment.
 
 ;; ## Basic usage
@@ -61,14 +61,12 @@
 ;; ### 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-like-this-word`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the word at the point.
-;;  - `mc/mark-next-like-this-symbol`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the symbol at the point.
 ;;  - `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 occurrences.
+;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
 ;;  - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
 
 ;; ### Mark many occurrences
@@ -87,7 +85,6 @@
 ;;  - `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.
 ;;  - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
-;;  - `mc/insert-letters`: Insert increasing letters for each cursor, top to bottom.
 ;;  - `mc/sort-regions`: Sort the marked regions alphabetically.
 ;;  - `mc/reverse-regions`: Reverse the order of the marked regions.
 
@@ -103,10 +100,6 @@
 ;; - 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-next-like-this-word` or
-;;   `mc/mark-next-like-this-symbol` with no region selected. It will
-;;   mark the symbol and add a cursor at the next occurrence
-;;
 ;; - 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.
@@ -186,11 +179,8 @@
 
 ;;; Code:
 
-(defgroup multiple-cursors nil
-  "Multiple cursors for emacs."
-  :group 'editing)
-
 (require 'mc-edit-lines)
+(require 'mc-cycle-cursors)
 (require 'mc-mark-more)
 (require 'mc-mark-pop)
 (require 'rectangular-region-mode)

rectangular-region-mode.el

@@ -1,6 +1,6 @@
 ;;; rectangular-region-mode.el
 
-;; Copyright (C) 2012-2016 Magnar Sveen
+;; Copyright (C) 2012 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@@ -38,8 +38,6 @@
 (define-key rectangular-region-mode-map (kbd "C-g") 'rrm/keyboard-quit)
 (define-key rectangular-region-mode-map (kbd "<return>") 'rrm/switch-to-multiple-cursors)
 
-(defvar rectangular-region-mode nil)
-
 (defun rrm/keyboard-quit ()
   "Exit rectangular-region-mode."
   (interactive)
@@ -75,9 +73,9 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
     (rrm/remove-rectangular-region-overlays)
     (let* ((annoying-arrows-mode nil)
            (point-column (current-column))
-           (point-line (mc/line-number-at-pos))
+           (point-line (line-number-at-pos))
            (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
-           (anchor-line (save-excursion (goto-char rrm/anchor) (mc/line-number-at-pos)))
+           (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
            (left-column (if (< point-column anchor-column) point-column anchor-column))
            (right-column (if (> point-column anchor-column) point-column anchor-column))
            (navigation-step (if (< point-line anchor-line) 1 -1)))
@@ -85,7 +83,7 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
       (set-mark (point))
       (move-to-column point-column)
       (mc/save-excursion
-       (while (not (= anchor-line (mc/line-number-at-pos)))
+       (while (not (= anchor-line (line-number-at-pos)))
          (forward-line navigation-step)
          (move-to-column anchor-column)
          (when (= anchor-column (current-column))
@@ -108,7 +106,6 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
   (when rectangular-region-mode
     (rrm/switch-to-multiple-cursors)))
 
-;;;###autoload
 (define-minor-mode rectangular-region-mode
   "A mode for creating a rectangular region to edit"
   nil " rr" rectangular-region-mode-map

run-tests.sh

@@ -1,2 +1,2 @@
 #!/bin/sh -e
-cask exec ecukes "$@" --no-win
+cask exec ecukes "$@"