Merge branch 'overwin' #130

Author: haya14busa

README.md

@@ -101,6 +101,57 @@ Jeffrey Way of Nettuts+ has also [written
 a tutorial](http://net.tutsplus.com/tutorials/other/vim-essential-plugin-easymotion/)
 about EasyMotion.
 
+New features in version 3.0
+====
+
+### Overwin motions
+![](https://raw.githubusercontent.com/haya14busa/i/2753bd4dd1dfdf5962dbdbffabf24244e4e14243/easymotion/overwin-motions.gif)
+
+EasyMotion now supports moving cursor across/over window.
+Since it doesn't make sense that moving cursor to other window while Visual or
+Operator-pending mode, overwin motions only provides mappings for Normal
+mode.  Please use `nmap` to use overwin motions. Overwin motions only
+supports bi-directional motions.
+
+#### Example configuration
+
+```vim
+" <Leader>f{char} to move to {char}
+map  <Leader>f <Plug>(easymotion-bd-f)
+nmap <Leader>f <Plug>(easymotion-overwin-f)
+
+" s{char}{char} to move to {char}{char}
+nmap s <Plug>(easymotion-overwin-f2)
+
+" Move to line
+map <Leader>L <Plug>(easymotion-bd-jk)
+nmap <Leader>L <Plug>(easymotion-overwin-line)
+
+" Move to word
+map  <Leader>w <Plug>(easymotion-bd-w)
+nmap <Leader>w <Plug>(easymotion-overwin-w)
+```
+
+#### Integration with incsearch.vim
+
+```vim
+" You can use other keymappings like <C-l> instead of <CR> if you want to
+" use these mappings as default search and somtimes want to move cursor with
+" EasyMotion.
+function! s:incsearch_config(...) abort
+  return incsearch#util#deepextend(deepcopy({
+  \   'modules': [incsearch#config#easymotion#module({'overwin': 1)],
+  \   'keymap': {
+  \     "\<CR>": '<Over>(easymotion)'
+  \   },
+  \   'is_expr': 0
+  \ }), get(a:, 1, {}))
+endfunction
+
+noremap <silent><expr> /  incsearch#go(<SID>incsearch_config())
+noremap <silent><expr> ?  incsearch#go(<SID>incsearch_config({'command': '?'}))
+noremap <silent><expr> g/ incsearch#go(<SID>incsearch_config({'is_stay': 1}))
+```
 
 New features in version 2.0
 ====

autoload/EasyMotion.vim

@@ -138,6 +138,10 @@ function! EasyMotion#S(num_strokes, visualmode, direction) " {{{
     call s:EasyMotion(re, a:direction, a:visualmode ? visualmode() : '', is_inclusive)
     return s:EasyMotion_is_cancelled
 endfunction " }}}
+function! EasyMotion#OverwinF(num_strokes) " {{{
+    let re = s:findMotion(a:num_strokes, s:DIRECTION.bidirection)
+    return EasyMotion#overwin#move(re)
+endfunction "}}}
 function! EasyMotion#T(num_strokes, visualmode, direction) " {{{
     if a:direction == 1
         let is_inclusive = 0
@@ -272,7 +276,8 @@ let s:config = {
 \   'visualmode': s:FALSE,
 \   'direction': s:DIRECTION.forward,
 \   'inclusive': s:FALSE,
-\   'accept_cursor_pos': s:FALSE
+\   'accept_cursor_pos': s:FALSE,
+\   'overwin': s:FALSE
 \ }
 
 function! s:default_config() abort
@@ -284,9 +289,13 @@ endfunction
 
 function! EasyMotion#go(...) abort
     let c = extend(s:default_config(), get(a:, 1, {}))
-    let s:current.is_operator = mode(1) ==# 'no' ? 1: 0
-    call s:EasyMotion(c.pattern, c.direction, c.visualmode ? visualmode() : '', c.inclusive, c)
-    return s:EasyMotion_is_cancelled
+    if c.overwin
+        return EasyMotion#overwin#move(c.pattern)
+    else
+        let s:current.is_operator = mode(1) ==# 'no' ? 1: 0
+        call s:EasyMotion(c.pattern, c.direction, c.visualmode ? visualmode() : '', c.inclusive, c)
+        return s:EasyMotion_is_cancelled
+    endif
 endfunction
 function! EasyMotion#User(pattern, visualmode, direction, inclusive, ...) " {{{
     let s:current.is_operator = mode(1) ==# 'no' ? 1: 0

autoload/EasyMotion/command_line.vim

@@ -137,6 +137,12 @@ endfunction "}}}
 function! s:search.on_leave(cmdline) "{{{
     if s:num_strokes == -1
         call EasyMotion#highlight#delete_highlight(g:EasyMotion_hl_inc_search)
+        if g:EasyMotion_do_shade
+            call EasyMotion#highlight#delete_highlight(g:EasyMotion_hl_group_shade)
+        endif
+    endif
+    if g:EasyMotion_cursor_highlight
+        call EasyMotion#highlight#delete_highlight(g:EasyMotion_hl_inc_cursor)
     endif
 endfunction "}}}
 function! s:search.on_char(cmdline) "{{{

autoload/EasyMotion/overwin.vim

@@ -0,0 +1,24 @@
+let s:V = vital#of('easymotion')
+let s:HitAHintMotion = s:V.import('HitAHint.Motion')
+
+function! EasyMotion#overwin#move(pattern) abort
+  return s:HitAHintMotion.move(a:pattern, {
+  \   'keys': g:EasyMotion_keys,
+  \   'use_upper': g:EasyMotion_use_upper,
+  \   'highlight': {
+  \     'shade': g:EasyMotion_hl_group_shade,
+  \     'target': g:EasyMotion_hl_group_target,
+  \   },
+  \   'jump_first_target_keys':
+  \     (g:EasyMotion_enter_jump_first ? ["\<CR>"] : []) +
+  \     (g:EasyMotion_space_jump_first ? ["\<Space>"] : [])
+  \ })
+endfunction
+
+function! EasyMotion#overwin#line() abort
+  return EasyMotion#overwin#move('^')
+endfunction
+
+function! EasyMotion#overwin#w() abort
+  return EasyMotion#overwin#move('\(\<.\|^$\)')
+endfunction

autoload/vital/_easymotion.vim

@@ -237,26 +237,16 @@ function! s:_build_module(sid) abort
   for func in functions
     let module[func] = function(prefix . func)
   endfor
+  if has_key(module, '_vital_created')
+    call module._vital_created(module)
+  endif
+  let export_module = filter(copy(module), 'v:key =~# "^\\a"')
+  let s:loaded[a:sid] = get(g:, 'vital_debug', 0) ? module : export_module
   if has_key(module, '_vital_loaded')
     let V = vital#{s:self_version}#new()
-    if has_key(module, '_vital_depends')
-      let all = {}
-      let modules =
-      \     s:_concat(map(module._vital_depends(),
-      \                   's:expand_modules(v:val, all)'))
-      call call(V.load, modules, V)
-    endif
-    try
-      call module._vital_loaded(V)
-    catch
-      " FIXME: Show an error message for debug.
-    endtry
-  endif
-  if !get(g:, 'vital_debug', 0)
-    call filter(module, 'v:key =~# "^\\a"')
+    call module._vital_loaded(V)
   endif
-  let s:loaded[a:sid] = module
-  return copy(module)
+  return copy(s:loaded[a:sid])
 endfunction
 
 if exists('+regexpengine')

autoload/vital/_easymotion/Data/List.vim

@@ -225,7 +225,7 @@ endfunction
 " similar to Haskell's Prelude.foldl1
 function! s:foldl1(f, xs) abort
   if len(a:xs) == 0
-    throw 'foldl1'
+    throw 'vital: Data.List: foldl1'
   endif
   return s:foldl(a:f, a:xs[0], a:xs[1:])
 endfunction
@@ -238,7 +238,7 @@ endfunction
 " similar to Haskell's Prelude.fold11
 function! s:foldr1(f, xs) abort
   if len(a:xs) == 0
-    throw 'foldr1'
+    throw 'vital: Data.List: foldr1'
   endif
   return s:foldr(a:f, a:xs[-1], a:xs[0:-2])
 endfunction
@@ -264,7 +264,7 @@ endfunction
 " Inspired by Ruby's with_index method.
 function! s:with_index(list, ...) abort
   let base = a:0 > 0 ? a:1 : 0
-  return s:zip(a:list, range(base, len(a:list)+base-1))
+  return map(copy(a:list), '[v:val, v:key + base]')
 endfunction
 
 " similar to Ruby's detect or Haskell's find.