Chain undos together in insert mode. Prevent ghostly cursors.

This commit provides basic chaining of undos in insert mode. Previously, undos
of changes made in multicursor mode are done one character at a time. This
change should chain all inserts into a single undo block, and undo them
together. This fixes #22.
We're also adding support to detect non-terminating single key commands. For
example, previously, 'd' would break multicursor mode and cause these ghostly
cursors to linger on screen, where the only way to get rid of them is to press
`<C-n>` somewhere to start a new multicursor mode. Now, these unterminated
commands are detected and simply cause a nop, execution continues and we're left
in multicursor mode. This paves the way to support multikey commands in the
future. This fixes #28.

Author: terryma

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.0 (04/24/2013)
+
+Bugfixes:
+  - Fix inconsistent undo behavior. Changes made in multicursor insert mode are now undone together. This fixes #22.
+  - Single key commands that do not terminate properly no longer cause ghostly cursors to linger on screen. An error message is now displayed informing the user the number of cursor locations that the input cannot be properly played back at. This fixes #28.
+
 ## 1.16 (04/23/2013)
 
 Features:

README.md

@@ -38,7 +38,7 @@ Two additional keys are also mapped:
 
 You can also add multiple cursors using a regular expression. The command `MultipleCursorsFind` accepts a range and a pattern, and it will create a virtual cursor at the end of every match within the range. If no range is passed in, then it defaults to the entire buffer.  
 
-**NOTE:** The plugin is still somewhat buggy, if at any time you have lingering cursors on screen, you can press `Ctrl-n` in Normal mode and it will remove all prior cursors before starting a new one.
+**NOTE:** If at any time you have lingering cursors on screen, you can press `Ctrl-n` in Normal mode and it will remove all prior cursors before starting a new one.
 
 ## Mapping
 Out of the box, only the single key `Ctrl-n` is mapped in regular Vim's Normal mode and Visual mode to provide the functionality mentioned above. `Ctrl-n`, `Ctrl-p`, `Ctrl-x`, and `<Esc>` are mapped in the special multicursor mode once you've added at least one virtual cursor to the buffer. If you don't like the plugin taking over your favorite key bindings, you can turn off the default with
@@ -88,11 +88,8 @@ highlight link multiple_cursors_visual Visual
 ## Issues
 - Multi key commands like `ciw` do not work at the moment
 - All user input typed before Vim is able to fan out the last operation to all cursors is lost. This is a implementation decision to keep the input perfectly synced in all locations, at the cost of potentially losing user input.
-- Single key commands that do not terminate properly cause unexpected behavior. For example, if the cursor is on the first character in the buffer and 'b' is pressed.
-- Undo behavior is unpredictable
 - Performance in terminal vim degrades significantly with more cursors
 - Select mode is not implemented
-- Buggy when `wrap` is turned on
 
 ## Changelog
 See [CHANGELOG.md](CHANGELOG.md)

autoload/multiple_cursors.vim

@@ -58,6 +58,14 @@ inoremap <silent> <Plug>(a) <C-o>:call <SID>apply_user_input_next('i')<CR>
 nnoremap <silent> <Plug>(a) :call <SID>apply_user_input_next('n')<CR>
 xnoremap <silent> <Plug>(a) :<C-u>call <SID>apply_user_input_next('v')<CR>
 
+inoremap <silent> <Plug>(d) <C-o>:call <SID>detect_bad_input()<CR>
+nnoremap <silent> <Plug>(d) :call <SID>detect_bad_input()<CR>
+xnoremap <silent> <Plug>(d) :<C-u>call <SID>detect_bad_input()<CR>
+
+inoremap <silent> <Plug>(w) <C-o>:call <SID>wait_for_user_input('')<CR>
+nnoremap <silent> <Plug>(w) :call <SID>wait_for_user_input('')<CR>
+xnoremap <silent> <Plug>(w) :<C-u>call <SID>wait_for_user_input('')<CR>
+
 " Note that although these mappings are seemingly triggerd from Visual mode,
 " they are in fact triggered from Normal mode. We quit visual mode to allow the
 " virtual highlighting to take over
@@ -556,6 +564,7 @@ function! s:CursorManager.add(pos, ...) dict
   let self.current_index += 1
   return 1
 endfunction
+
 "===============================================================================
 " Variables
 "===============================================================================
@@ -570,6 +579,9 @@ let s:to_mode = ''
 let s:saved_linecount = -1
 " This is used to apply the highlight fix. See s:apply_highight_fix()
 let s:saved_line = 0
+" This is the number of cursor locations where we detected an input that we
+" cannot play back
+let s:bad_input = 0
 " Singleton cursor manager instance
 let s:cm = s:CursorManager.new()
 
@@ -745,12 +757,42 @@ function! s:process_user_inut()
 
   " Apply the user input. Note that the above could potentially change mode, we
   " use the mapping below to help us determine what the new mode is
-  " FIXME(terryma): It's possible that \<Plug>(a) never gets called
-  call s:feedkeys(s:char."\<Plug>(a)")
+  " Note that it's possible that \<Plug>(a) never gets called, we have a
+  " detection mechanism using \<Plug>(d). See its documentation for more details
+
+  " Assume that input is not valid
+  let s:valid_input = 0
+
+  " If we're coming from insert mode or going into insert mode, always chain the
+  " undos together.
+  " FIXME(terryma): Undo always places the cursor at the beginning of the line.
+  " Figure out why.
+  if s:from_mode ==# 'i' || s:to_mode ==# 'i'
+    silent! undojoin | call feedkeys(s:char."\<Plug>(a)")
+  else
+    call feedkeys(s:char."\<Plug>(a)")
+  endif
+  
+  " Even when s:char produces invalid input, this method is always called. The
+  " 't' here is important
+  call feedkeys("\<Plug>(d)", 't')
+endfunction
+
+" This method is always called during fanout, even when a bad user input causes
+" s:apply_user_input_next to not be called. We detect that and force the method
+" to be called to continue the fanout process
+function! s:detect_bad_input()
+  if !s:valid_input
+    " We ignore the bad input and force invoke s:apply_user_input_next
+    call feedkeys("\<Plug>(a)")
+    let s:bad_input += 1
+  endif
 endfunction
 
 " Apply the user input at the next cursor location
 function! s:apply_user_input_next(mode)
+  let s:valid_input = 1
+
   " Save the current mode, only if we haven't already
   if empty(s:to_mode)
     let s:to_mode = a:mode
@@ -776,10 +818,10 @@ function! s:apply_user_input_next(mode)
       " This is necessary to set the "'<" and "'>" markers properly
       call s:update_visual_markers(s:cm.get_current().visual)
     endif
-    call s:wait_for_user_input(s:to_mode)
+    call feedkeys("\<Plug>(w)")
   else
     " Continue to next
-    call s:process_user_inut()
+    call feedkeys("\<Plug>(i)")
   endif
 endfunction
 
@@ -869,22 +911,45 @@ function! s:apply_highlight_fix()
   " Only do this if we're on the last character of the line
   if col('.') == col('$')
     let s:saved_line = getline('.')
-    call setline('.', s:saved_line.' ')
+    if s:from_mode ==# 'i'
+      silent! undojoin | call setline('.', s:saved_line.' ')
+    else
+      call setline('.', s:saved_line.' ')
+    endif
   endif
 endfunction
 
 " Revert the fix if it was applied earlier
 function! s:revert_highlight_fix()
   if type(s:saved_line) == 1
-    call setline('.', s:saved_line)
+    if s:from_mode ==# 'i'
+      silent! undojoin | call setline('.', s:saved_line)
+    else 
+      call setline('.', s:saved_line)
+    endif
   endif
   let s:saved_line = 0
 endfunction
 
+function! s:display_error()
+  if s:bad_input > 0
+    echohl ErrorMsg |
+          \ echo "Key '".s:char."' cannot be replayed at ".
+          \ s:bad_input." cursor location".(s:bad_input == 1 ? '' : 's') |
+          \ echohl Normal
+  endif
+  let s:bad_input = 0
+endfunction
+
 function! s:wait_for_user_input(mode)
   let s:from_mode = a:mode
+  if empty(a:mode)
+    let s:from_mode = s:to_mode
+  endif
   let s:to_mode = ''
 
+  call s:display_error()
+
   " Right before redraw, apply the highlighting bug fix
   call s:apply_highlight_fix()
 

doc/multiple_cursors.txt

@@ -66,9 +66,9 @@ You can also add multiple cursors using a regular expression. The command
 virtual cursor at the end of every match within the range. If no range is
 passed in, then it defaults to the entire buffer.
 
-NOTE: The plugin is still somewhat buggy, if at any time you have
-lingering cursors on screen, you can press CTRL-N in Normal mode and it will
-remove all prior cursors before starting a new one.
+NOTE: If at any time you have lingering cursors on screen, you can press
+CTRL-N in Normal mode and it will remove all prior cursors before starting a
+new one.
 
 ==============================================================================
 3. Mappings                                        *multiple-cursors-mappings* 
@@ -160,13 +160,8 @@ like the following in your vimrc: >
   cursors is lost. This is a implementation decision to keep the input
   perfectly synced in all locations, at the cost of potentially losing user
   input.
-- Single key commands that do not terminate properly cause unexpected
-  behavior. For example, if the cursor is on the first character in the buffer
-  and 'b' is pressed.
-- Undo behavior is unpredictable
 - Performance in terminal vim degrades significantly with more cursors
 - Select mode is not implemented
-- Buggy when wrap is turned on
 
 ==============================================================================
 6. Contributing                                *multiple-cursors-contributing* 

spec/multiple_cursors_spec.rb

@@ -90,6 +90,22 @@ def type(string)
     EOF
   end
 
+  specify "#new line in insert mode middle of line" do
+    before <<-EOF
+      hello world
+      hello world
+    EOF
+
+    type '<C-n><C-n>vlxi<cr><Esc>'
+
+    after <<-EOF
+      hello
+      world
+      hello
+      world
+    EOF
+  end
+
   specify "#normal mode 'o'" do
     before <<-EOF
       hello
@@ -150,4 +166,94 @@ def type(string)
       hi!
     EOF
   end
+
+  specify "#skip key" do
+    before <<-EOF
+      hello
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n><C-x>cworld<Esc>'
+
+    after <<-EOF
+      world
+      hello
+      world
+    EOF
+  end
+
+  specify "#prev key" do
+    before <<-EOF
+      hello
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n><C-n><C-p>cworld<Esc>'
+
+    after <<-EOF
+      world
+      world
+      hello
+    EOF
+  end
+
+  specify "#normal mode 'I'" do
+    before <<-EOF
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n>vIworld <Esc>'
+
+    after <<-EOF
+      world hello
+      world hello
+    EOF
+  end
+
+  specify "#normal mode 'A'" do
+    before <<-EOF
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n>vA world<Esc>'
+
+    after <<-EOF
+      hello world
+      hello world
+    EOF
+  end
+
+  specify "#undo" do
+    before <<-EOF
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n>cworld<Esc>u'
+
+    after <<-EOF
+      hello
+      hello
+    EOF
+  end
+
+  # 'd' is an operator pending command, which are not supported at the moment.
+  # This should result in a nop, but we should still remain in multicursor mode.
+  specify "#normal mode 'd'" do
+    before <<-EOF
+      hello
+      hello
+    EOF
+
+    type '<C-n><C-n>vdx<Esc>'
+
+    after <<-EOF
+      hell
+      hell
+    EOF
+  end
 end