└── plugin
    └── flatfoot.vim


/plugin/flatfoot.vim:
--------------------------------------------------------------------------------
  1 | " flatfoot.vim - Flatfoot
  2 | " Maintainer:   Tim Pope
  3 | 
  4 | " Flatfoot helps you to quickly jump to arbitrary predefined short patterns
  5 | " within a line.  An example might be to jump between the "humps" of a
  6 | " camelCaseWord.  The interface involves passing f, t, F, or T a control
  7 | " character which corresponds to a predefined regexp.  The ; and , commands
  8 | " will use this regexp as one would expect.
  9 | "
 10 | " A global variable named flatfoot_1 contains the regexp for CTRL-A, and
 11 | " flatfoot_26 CTRL-Z.  In other words, the decimal ASCII value of the key
 12 | " press becomes the number at the end of the variable.  For example,
 13 | "
 14 | "   :let flatfoot_21 = '\u'
 15 | "
 16 | " sets CTRL-U to find the next uppercase character.  CTRL-U comes predefined
 17 | " for this, and CTRL-W and CTRL-E comes predefined to handle the beginning and
 18 | " ending of camelCase and snake_case words.
 19 | "
 20 | " If you like the power of this plugin but don't like the awkward use of
 21 | " control characters, the following alternate (but discouraged) alternative is
 22 | " provided:
 23 | "
 24 | "   nmap <silent><expr> <Leader>u Flatfoot('f','\u')
 25 | "   xmap <silent><expr> <Leader>u Flatfoot('f','\u')
 26 | "   omap <silent><expr> <Leader>u Flatfoot('f','\u','o')
 27 | "
 28 | " The first argument is the kind of search to use (f, t, F, or T), and the
 29 | " second is the pattern.  The optional third argument indicates the mode.
 30 | " Since there is no way to detect operator pending mode, you MUST provide
 31 | " both a regular map and an omap, as shown above.
 32 | 
 33 | " Exit quickly when:
 34 | " - this plugin was already loaded (or disabled)
 35 | " - when 'compatible' is set
 36 | " - the version is less than 7.0
 37 | if (exists("g:loaded_flatfoot") && g:loaded_flatfoot) || &cp || v:version < 700
 38 |     finish
 39 | endif
 40 | let g:loaded_flatfoot = 1
 41 | 
 42 | let s:cpo_save = &cpo
 43 | set cpo&vim
 44 | 
 45 | " Defaults {{{1
 46 | 
 47 | if !exists("g:flatfoot_".char2nr("\<C-U>"))
 48 |     let flatfoot_{char2nr("\<C-U>")} = '\u'
 49 | endif
 50 | if !exists("g:flatfoot_".char2nr("\<C-W>"))
 51 |     let flatfoot_{char2nr("\<C-W>")} = '\C[[:alnum:]]\@<![[:alnum:]]\|[^[:upper:]]\@<=[[:upper:]]\|[[:upper:]][[:lower:]]\@='
 52 | endif
 53 | if !exists("g:flatfoot_".char2nr("\<C-E>"))
 54 |     let flatfoot_{char2nr("\<C-E>")} = '\C[[:alnum:]][[:alnum:]]\@!\|[[:lower:][:digit:]][[:upper:]]\@=\|[[:upper:]]\%([[:upper:]][[:lower:]]\)\@='
 55 | endif
 56 | 
 57 | " }}}1
 58 | " Code {{{1
 59 | 
 60 | function! s:escapemode(mode)
 61 |     let mode = a:mode == "" ? mode() : a:mode
 62 |     let mode = mode == "\<C-V>" ? "\<C-V>" . mode : mode
 63 |     return mode
 64 | endfunction
 65 | 
 66 | function! Flatfoot(op,pattern,...)
 67 |     let mode = s:escapemode(a:0 ? a:1 : mode())
 68 |     return ''.":\<C-U>call FlatfootFindPattern(".string(a:op).",".string(a:pattern).",'".mode."')\<CR>"
 69 | endfunction
 70 | 
 71 | function! s:findexpr(op,mode,...)
 72 |     let c = a:0 ? a:1 : getchar()
 73 |     if !exists("g:flatfoot_".c) && !exists("b:flatfoot_".c)
 74 |         unlet! s:last_pattern
 75 |         unlet! s:last_reverse
 76 |         return a:op.nr2char(c)
 77 |     endif
 78 |     let mode = s:escapemode(a:mode)
 79 |     return ''.":\<C-U>call FlatfootFindChar('".a:op."',".c.",'".mode."')\<CR>"
 80 | endfunction
 81 | 
 82 | function! FlatfootFindChar(op,c,mode)
 83 |     let pat = exists("b:flatfoot_".a:c) ? b:flatfoot_{a:c} : g:flatfoot_{a:c}
 84 |     return FlatfootFindPattern(a:op,pat,a:mode)
 85 | endfunction
 86 | 
 87 | function! FlatfootFindPattern(op,pattern,mode)
 88 |     let pattern = a:pattern
 89 |     let reverse = ''
 90 |     if a:op ==# 't'
 91 |         let pattern = '.\%(' . pattern . '\)'
 92 |     elseif a:op ==# 'T'
 93 |         let pattern = '\%(' . pattern . '\)\zs.'
 94 |         let reverse = 'b'
 95 |     elseif a:op ==# 'F'
 96 |         let reverse = 'b'
 97 |     endif
 98 |     let s:last_pattern = pattern
 99 |     let s:last_reverse = reverse
100 |     return s:go(pattern, reverse, v:count1, a:mode)
101 | endfunction
102 | 
103 | 
104 | function! s:repeatexpr(op,mode)
105 |     let mode = s:escapemode(a:mode)
106 |     if exists("s:last_pattern")
107 |         return ''.":\<C-U>call FlatfootFindLast('".a:op."','".mode."')\<CR>"
108 |     else
109 |         return a:op
110 |     endif
111 | endfunction
112 | 
113 | function! FlatfootFindLast(op,mode)
114 |     if a:op == ","
115 |         let reverse = s:last_reverse ==# 'b' ? '' : 'b'
116 |     else
117 |         let reverse = s:last_reverse
118 |     endif
119 |     return s:go(s:last_pattern, reverse, v:count1, a:mode)
120 | endfunction
121 | 
122 | function! s:adjustmode(mode)
123 |     if a:mode ==? "v" || a:mode == "\<C-V>"
124 |         norm! gv
125 |     elseif a:mode == "o"
126 |         norm! v
127 |     endif
128 | endfunction
129 | 
130 | function! s:go(pattern,reverse,count,mode)
131 |     call s:adjustmode(a:mode)
132 |     "let g:debug = v:count1 . a:pattern . a:reverse . col('.')
133 |     let oldcol = virtcol('.')
134 |     let i = 0
135 |     while i < v:count1
136 |         if !search(a:pattern,a:reverse,line('.'))
137 |             exe "norm! ".oldcol."|"
138 |             " Use escape to beep, but don't cancel visual mode
139 |             if a:mode !=? "v" && a:mode != "\<C-V>"
140 |                 exe "norm! \<Esc>"
141 |             endif
142 |             return 0
143 |         endif
144 |         let i = i + 1
145 |     endwhile
146 |     return col('.')
147 | endfunction
148 | 
149 | " }}}1
150 | " Maps {{{1
151 | 
152 | nnoremap <silent> <expr> <SID>f <SID>findexpr('f',mode(),getchar())
153 | nnoremap <silent> <expr> <SID>F <SID>findexpr('F',mode(),getchar())
154 | nnoremap <silent> <expr> <SID>t <SID>findexpr('t',mode(),getchar())
155 | nnoremap <silent> <expr> <SID>T <SID>findexpr('T',mode(),getchar())
156 | nnoremap <silent> <expr> <SID>; <SID>repeatexpr(';',mode())
157 | nnoremap <silent> <expr> <SID>, <SID>repeatexpr(',',mode())
158 | xnoremap <silent> <expr> <SID>f <SID>findexpr('f',mode(),getchar())
159 | xnoremap <silent> <expr> <SID>F <SID>findexpr('F',mode(),getchar())
160 | xnoremap <silent> <expr> <SID>t <SID>findexpr('t',mode(),getchar())
161 | xnoremap <silent> <expr> <SID>T <SID>findexpr('T',mode(),getchar())
162 | xnoremap <silent> <expr> <SID>; <SID>repeatexpr(';',mode())
163 | xnoremap <silent> <expr> <SID>, <SID>repeatexpr(',',mode())
164 | onoremap <silent> <expr> <SID>f <SID>findexpr('f','o',getchar())
165 | onoremap <silent> <expr> <SID>F <SID>findexpr('F','o',getchar())
166 | onoremap <silent> <expr> <SID>t <SID>findexpr('t','o',getchar())
167 | onoremap <silent> <expr> <SID>T <SID>findexpr('T','o',getchar())
168 | onoremap <silent> <expr> <SID>; <SID>repeatexpr(';','o')
169 | onoremap <silent> <expr> <SID>, <SID>repeatexpr(',','o')
170 | 
171 | nnoremap  <silent> <script> f <SID>f
172 | nnoremap  <silent> <script> F <SID>F
173 | nnoremap  <silent> <script> t <SID>t
174 | nnoremap  <silent> <script> T <SID>T
175 | nnoremap  <silent> <script> ; <SID>;
176 | nnoremap  <silent> <script> , <SID>,
177 | xnoremap  <silent> <script> f <SID>f
178 | xnoremap  <silent> <script> F <SID>F
179 | xnoremap  <silent> <script> t <SID>t
180 | xnoremap  <silent> <script> T <SID>T
181 | xnoremap  <silent> <script> ; <SID>;
182 | xnoremap  <silent> <script> , <SID>,
183 | onoremap  <silent> <script> f <SID>f
184 | onoremap  <silent> <script> F <SID>F
185 | onoremap  <silent> <script> t <SID>t
186 | onoremap  <silent> <script> T <SID>T
187 | onoremap  <silent> <script> ; <SID>;
188 | onoremap  <silent> <script> , <SID>,
189 | 
190 | " }}}1
191 | 
192 | let &cpo = s:cpo_save
193 | 
194 | " vim:set ft=vim ff=unix ts=8 sw=4 sts=4:
195 | 


--------------------------------------------------------------------------------