├── .gitignore
├── .travis.yml
├── Gemfile
├── Rakefile
├── VimFlavor
├── autoload
    └── smartinput.vim
├── doc
    └── smartinput.txt
├── plugin
    └── smartinput.vim
└── t
    ├── api.vim
    ├── beep-on-empty-line.t
    ├── beep-on-empty-line.vim
    ├── break-undo.vim
    ├── map_trigger_keys.vim
    ├── misc.vim
    ├── proper-initialization.vim
    ├── startup-no-default-key-mappings.vim
    └── startup-preserving-existing-key-mappings.vim


/.gitignore:
--------------------------------------------------------------------------------
1 | .vim-flavor
2 | Gemfile.lock
3 | VimFlavor.lock
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: vim
 2 | cache:
 3 | directories:
 4 |   - $HOME/.rvm
 5 |   - $HOME/.vvm
 6 | before_install:
 7 | - curl https://raw.githubusercontent.com/kana/vim-version-manager/master/bin/vvm | python - setup; true
 8 | - source ~/.vvm/etc/login
 9 | - vvm update_itself
10 | - vvm use vimorg--v8.0.1529 --install --with-features=huge
11 | -
12 | - rvm use 2.5.0 --install --binary --fuzzy
13 | script: rake ci
14 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | gem 'vim-flavor', '~> 2.1'
4 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env rake
 2 | 
 3 | task :ci => [:dump, :test]
 4 | 
 5 | task :dump do
 6 | sh 'vim --version'
 7 | end
 8 | 
 9 | task :test do
10 | sh 'bundle exec vim-flavor test'
11 | end
12 | 


--------------------------------------------------------------------------------
/VimFlavor:
--------------------------------------------------------------------------------
1 | # No dependencies.
2 | 


--------------------------------------------------------------------------------
/autoload/smartinput.vim:
--------------------------------------------------------------------------------
  1 | " smartinput - Provide smart input assistant
  2 | " Version: 0.1.0
  3 | " Copyright (C) 2012-2018-2018 Kana Natsuno <http://whileimautomaton.net/>
  4 | " License: MIT license  {{{
  5 | "     Permission is hereby granted, free of charge, to any person obtaining
  6 | "     a copy of this software and associated documentation files (the
  7 | "     "Software"), to deal in the Software without restriction, including
  8 | "     without limitation the rights to use, copy, modify, merge, publish,
  9 | "     distribute, sublicense, and/or sell copies of the Software, and to
 10 | "     permit persons to whom the Software is furnished to do so, subject to
 11 | "     the following conditions:
 12 | "
 13 | "     The above copyright notice and this permission notice shall be included
 14 | "     in all copies or substantial portions of the Software.
 15 | "
 16 | "     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 17 | "     OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 18 | "     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 19 | "     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 20 | "     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 21 | "     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 22 | "     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 23 | " }}}
 24 | " Naming guidelines  "{{{1
 25 | " Rules  "{{{2
 26 | "
 27 | " "urule" stands for "Unnormalized RULE".
 28 | " urules are rules written by users.
 29 | " Optional items may be omitted from urules.
 30 | "
 31 | " "nrule" stands for "Normalized RULE".
 32 | " nrules are rules completed with all optional items and internal items.
 33 | "
 34 | " "snrule" stands for "SemiNormalized RULE".
 35 | " snrules are mostly same as nrules, the only one difference is that
 36 | " "priority" items may be omitted from snrules.
 37 | 
 38 | 
 39 | 
 40 | 
 41 | 
 42 | 
 43 | 
 44 | 
 45 | " Variables  "{{{1
 46 | let s:available_nrules = []  "{{{2
 47 | " :: [NRule] -- it is ALWAYS sorted by priority in descending order.
 48 | 
 49 | 
 50 | 
 51 | 
 52 | "{{{2
 53 | 
 54 | 
 55 | 
 56 | 
 57 | " Interface  "{{{1
 58 | function! smartinput#clear_rules()  "{{{2
 59 |   let s:available_nrules = []
 60 | endfunction
 61 | 
 62 | 
 63 | 
 64 | 
 65 | function! smartinput#define_default_rules()  "{{{2
 66 |   " urules  "{{{
 67 |   let urules = {}
 68 |   let urules.names = []
 69 |   let urules.table = {}
 70 |   function! urules.add(name, urules)
 71 |     call add(self.names, a:name)
 72 |     let self.table[a:name] = a:urules
 73 |   endfunction
 74 |   if get(g:, 'smartinput_break_undo', 0) || v:version < 800
 75 |     let left = '<Left>'
 76 |     let right = '<Right>'
 77 |   else
 78 |     let left = '<C-g>U<Left>'
 79 |     let right = '<C-g>U<Right>'
 80 |   endif
 81 |   call urules.add('()', [
 82 |   \   {'at': '\%#', 'char': '(', 'input': '()'.left},
 83 |   \   {'at': '\%#\_s*)', 'char': ')', 'input': '<C-r>=smartinput#_leave_block('')'')<Enter>'.right},
 84 |   \   {'at': '(\%#)', 'char': '<BS>', 'input': '<BS><Del>'},
 85 |   \   {'at': '()\%#', 'char': '<BS>', 'input': '<BS><BS>'},
 86 |   \   {'at': '\\\%#', 'char': '(', 'input': '('},
 87 |   \   {'at': '(\%#)', 'char': '<Enter>', 'input': '<Enter><Enter><Up><Esc>"_S'},
 88 |   \ ])
 89 |   call urules.add('[]', [
 90 |   \   {'at': '\%#', 'char': '[', 'input': '[]'.left},
 91 |   \   {'at': '\%#\_s*\]', 'char': ']', 'input': '<C-r>=smartinput#_leave_block('']'')<Enter>'.right},
 92 |   \   {'at': '\[\%#\]', 'char': '<BS>', 'input': '<BS><Del>'},
 93 |   \   {'at': '\[\]\%#', 'char': '<BS>', 'input': '<BS><BS>'},
 94 |   \   {'at': '\\\%#', 'char': '[', 'input': '['},
 95 |   \ ])
 96 |   call urules.add('{}', [
 97 |   \   {'at': '\%#', 'char': '{', 'input': '{}'.left},
 98 |   \   {'at': '\%#\_s*}', 'char': '}', 'input': '<C-r>=smartinput#_leave_block(''}'')<Enter>'.right},
 99 |   \   {'at': '{\%#}', 'char': '<BS>', 'input': '<BS><Del>'},
100 |   \   {'at': '{}\%#', 'char': '<BS>', 'input': '<BS><BS>'},
101 |   \   {'at': '\\\%#', 'char': '{', 'input': '{'},
102 |   \   {'at': '{\%#}', 'char': '<Enter>', 'input': '<Enter><Enter><Up><Esc>"_S'},
103 |   \ ])
104 |   call urules.add('''''', [
105 |   \   {'at': '\%#', 'char': '''', 'input': ''''''.left},
106 |   \   {'at': '\%#''\ze', 'char': '''', 'input': ''.right},
107 |   \   {'at': '''\%#''', 'char': '<BS>', 'input': '<BS><Del>'},
108 |   \   {'at': '''''\%#', 'char': '<BS>', 'input': '<BS><BS>'},
109 |   \   {'at': '\\\%#\ze', 'char': '''', 'input': ''''},
110 |   \ ])
111 |   " Though strong quote is a useful feature and it is supported in several
112 |   " languages, \ is usually used to escape next charcters in most languages.
113 |   " So that rules for strong quote are written as additional ones for specific
114 |   " 'filetype's which override the default behavior.
115 |   call urules.add(''''' as strong quote', [
116 |   \   {'at': '\%#''', 'char': '''', 'input': ''.right},
117 |   \ ])
118 |   call urules.add('''''''', [
119 |   \   {'at': '''''\%#', 'char': '''', 'input': ''''''''''.left.left.left},
120 |   \   {'at': '\%#''''''\ze', 'char': '''', 'input': ''.right.right.right},
121 |   \   {'at': '''''''\%#''''''', 'char': '<BS>', 'input': '<BS><BS><BS><Del><Del><Del>'},
122 |   \   {'at': '''''''''''''\%#', 'char': '<BS>', 'input': '<BS><BS><BS><BS><BS><BS>'},
123 |   \ ])
124 |   call urules.add('""', [
125 |   \   {'at': '\%#', 'char': '"', 'input': '""'.left},
126 |   \   {'at': '\%#"', 'char': '"', 'input': ''.right},
127 |   \   {'at': '"\%#"', 'char': '<BS>', 'input': '<BS><Del>'},
128 |   \   {'at': '""\%#', 'char': '<BS>', 'input': '<BS><BS>'},
129 |   \   {'at': '\\\%#', 'char': '"', 'input': '"'},
130 |   \ ])
131 |   call urules.add('"""', [
132 |   \   {'at': '""\%#', 'char': '"', 'input': '""""'.left.left.left},
133 |   \   {'at': '\%#"""', 'char': '"', 'input': ''.right.right.right},
134 |   \   {'at': '"""\%#"""', 'char': '<BS>', 'input': '<BS><BS><BS><Del><Del><Del>'},
135 |   \   {'at': '""""""\%#', 'char': '<BS>', 'input': '<BS><BS><BS><BS><BS><BS>'},
136 |   \ ])
137 |   call urules.add('``', [
138 |   \   {'at': '\%#', 'char': '`', 'input': '``'.left},
139 |   \   {'at': '\%#`', 'char': '`', 'input': ''.right},
140 |   \   {'at': '`\%#`', 'char': '<BS>', 'input': '<BS><Del>'},
141 |   \   {'at': '``\%#', 'char': '<BS>', 'input': '<BS><BS>'},
142 |   \   {'at': '\\\%#', 'char': '`', 'input': '`'},
143 |   \ ])
144 |   call urules.add('```', [
145 |   \   {'at': '``\%#', 'char': '`', 'input': '````'.left.left.left},
146 |   \   {'at': '\%#```', 'char': '`', 'input': ''.right.right.right},
147 |   \   {'at': '```\%#```', 'char': '<BS>', 'input': '<BS><BS><BS><Del><Del><Del>'},
148 |   \   {'at': '``````\%#', 'char': '<BS>', 'input': '<BS><BS><BS><BS><BS><BS>'},
149 |   \ ])
150 |   call urules.add('English', [
151 |   \   {'at': '\w\%#', 'char': '''', 'input': ''''},
152 |   \ ])
153 |   call urules.add('Lisp quote', [
154 |   \   {'at': '\%#', 'char': '''', 'input': ''''},
155 |   \   {'at': '\%#', 'char': '''', 'input': ''''''.left.'',
156 |   \    'syntax': ['Constant']},
157 |   \ ])
158 |   " Unfortunately, the space beyond the end of a comment line is not
159 |   " highlighted as 'Comment'.  So that it is necessary to define one more rule
160 |   " to cover the edge case with only 'at'.
161 |   call urules.add('Python string', [
162 |   \   {'at': '\v\c<([bu]|[bu]?r)>%#', 'char': '''', 'input': ''''''.left},
163 |   \   {'at': '\v\c<([bu]|[bu]?r)>%#', 'char': '''', 'input': '''',
164 |   \    'syntax': ['Comment', 'Constant']},
165 |   \   {'at': '\v\c\#.*<([bu]|[bu]?r)>%#$', 'char': '''', 'input': ''''},
166 |   \ ])
167 |   call urules.add('Vim script comment', [
168 |   \   {'at': '^\s*\%#', 'char': '"', 'input': '"'},
169 |   \ ])
170 |   "}}}
171 | 
172 |   " ft_urule_sets_table... "{{{
173 |   let ft_urule_sets_table = {
174 |   \   '*': [
175 |   \     urules.table['()'],
176 |   \     urules.table['[]'],
177 |   \     urules.table['{}'],
178 |   \     urules.table[''''''],
179 |   \     urules.table[''''''''],
180 |   \     urules.table['""'],
181 |   \     urules.table['"""'],
182 |   \     urules.table['``'],
183 |   \     urules.table['```'],
184 |   \     urules.table['English'],
185 |   \   ],
186 |   \   'clojure': [
187 |   \     urules.table['Lisp quote'],
188 |   \   ],
189 |   \   'csh': [
190 |   \     urules.table[''''' as strong quote'],
191 |   \   ],
192 |   \   'lisp': [
193 |   \     urules.table['Lisp quote'],
194 |   \   ],
195 |   \   'perl': [
196 |   \     urules.table[''''' as strong quote'],
197 |   \   ],
198 |   \   'python': [
199 |   \     urules.table['Python string'],
200 |   \   ],
201 |   \   'ruby': [
202 |   \     urules.table[''''' as strong quote'],
203 |   \   ],
204 |   \   'scheme': [
205 |   \     urules.table['Lisp quote'],
206 |   \   ],
207 |   \   'sh': [
208 |   \     urules.table[''''' as strong quote'],
209 |   \   ],
210 |   \   'tcsh': [
211 |   \     urules.table[''''' as strong quote'],
212 |   \   ],
213 |   \   'vim': [
214 |   \     urules.table[''''' as strong quote'],
215 |   \     urules.table['Vim script comment'],
216 |   \   ],
217 |   \   'zsh': [
218 |   \     urules.table[''''' as strong quote'],
219 |   \   ],
220 |   \ }
221 |   "}}}
222 | 
223 |   for urule_set in ft_urule_sets_table['*']
224 |     for urule in urule_set
225 |       call smartinput#define_rule(urule)
226 |     endfor
227 |   endfor
228 | 
229 |   let overlaied_urules = {}
230 |   let overlaied_urules.pairs = []  " [(URule, [FileType])]
231 |   function! overlaied_urules.add(urule, ft)
232 |     for [urule, fts] in self.pairs
233 |       if urule is a:urule
234 |         call add(fts, a:ft)
235 |         return
236 |       endif
237 |     endfor
238 |     call add(self.pairs, [a:urule, [a:ft]])
239 |   endfunction
240 |   for ft in filter(keys(ft_urule_sets_table), 'v:val != "*"')
241 |     for urule_set in ft_urule_sets_table[ft]
242 |       for urule in urule_set
243 |         call overlaied_urules.add(urule, ft)
244 |       endfor
245 |     endfor
246 |   endfor
247 |   for [urule, fts] in overlaied_urules.pairs
248 |     let completed_urule = copy(urule)
249 |     let completed_urule.filetype = fts
250 |     call smartinput#define_rule(completed_urule)
251 |   endfor
252 | 
253 |   " Add more useful rules?
254 | endfunction
255 | 
256 | function! s:_operator_key_from(operator_name)
257 |   let k = a:operator_name
258 |   let k = substitute(k, '\V<', '<LT>', 'g')
259 |   let k = substitute(k, '\V|', '<Bar>', 'g')
260 |   return k
261 | endfunction
262 | 
263 | function! s:_operator_pattern_from(operator_name)
264 |   let k = a:operator_name
265 |   return k
266 | endfunction
267 | 
268 | function! smartinput#_leave_block(end_char)
269 |   " NB: Originally <C-o> was used to execute search(), but <C-o> in
270 |   " Visual-block Insert acts as if <Esc>a, so visually selected lines will be
271 |   " updated and the current mode will be shifted to Insert mode.  It means
272 |   " that there is no timing to execute a Normal mode command.  Therefore we
273 |   " have to use <C-r>= instead.
274 |   call search(a:end_char, 'cW')
275 |   return ''
276 | endfunction
277 | 
278 | 
279 | 
280 | 
281 | function! smartinput#define_rule(urule)  "{{{2
282 |   let nrule = s:normalize_rule(a:urule)
283 |   call s:insert_or_replace_a_rule(s:available_nrules, nrule)
284 | endfunction
285 | 
286 | 
287 | 
288 | 
289 | function! smartinput#map_to_trigger(mode, lhs, rhs_char, rhs_fallback)  "{{{2
290 |   " According to :help 'autoindent' --
291 |   "
292 |   " > Copy indent from current line when starting a new line
293 |   " > (typing <CR> in Insert mode or when using the "o" or "O" command).
294 |   " > If you do not type anything on the new line except <BS> or CTRL-D
295 |   " > and then type <Esc>, CTRL-O or <CR>, the indent is deleted again.
296 |   "
297 |   " So that a:rhs_fallback MUST be mapped from a:lhs without leaving from
298 |   " Insert mode to keep the behavior on automatic indentation when
299 |   " a:rhs_fallback == '<Enter>',
300 |   let char_expr = s:_encode_for_map_char_expr(a:rhs_char)
301 |   let fallback_expr = s:_encode_for_map_char_expr(a:rhs_fallback)
302 |   execute printf('%snoremap %s %s  <SID>_trigger_or_fallback(%s, %s)',
303 |   \              a:mode,
304 |   \              '<script> <expr>',
305 |   \              a:lhs,
306 |   \              char_expr,
307 |   \              fallback_expr)
308 | endfunction
309 | 
310 | function! s:_encode_for_map_char_expr(rhs_char)
311 |   let s = a:rhs_char
312 |   let s = substitute(s, '<', '<Bslash><LT>', 'g')
313 |   let s = escape(s, '"')
314 |   let s = '"' . s . '"'
315 |   return s
316 | endfunction
317 | 
318 | function! s:_trigger_or_fallback(char, fallback)
319 |   let nrule =
320 |   \ mode() =~# '\v^(i|R|Rv)$'
321 |   \ ? s:find_the_most_proper_rule_in_insert_mode(
322 |   \     s:available_nrules,
323 |   \     a:char
324 |   \   )
325 |   \ : s:find_the_most_proper_rule_in_command_line_mode(
326 |   \     s:available_nrules,
327 |   \     a:char,
328 |   \     getcmdline(),
329 |   \     getcmdpos(),
330 |   \     getcmdtype()
331 |   \   )
332 |   if nrule is 0
333 |     return a:fallback
334 |   else
335 |     return nrule._input
336 |   endif
337 | endfunction
338 | 
339 | 
340 | 
341 | 
342 | function! smartinput#map_trigger_keys(...)  "{{{2
343 |   let overridep = 1 <= a:0 ? a:1 : 0
344 | 
345 |   let d = {'i': {}, 'c': {}}
346 |   for nrule in s:available_nrules
347 |     let char = nrule.char
348 |     if nrule.mode =~# 'i'
349 |       let d['i'][char] = char
350 |     endif
351 |     if nrule.mode =~# '[^i]'
352 |       let d['c'][char] = char
353 |     endif
354 |   endfor
355 | 
356 |   let M = function('smartinput#map_to_trigger')
357 |   let map_modifier = overridep ? '' : '<unique>'
358 |   for mode in keys(d)
359 |     let unique_chars = keys(d[mode])
360 |     for char in unique_chars
361 |       " Do not override existing key mappings.
362 |       silent! call M(mode, map_modifier.' '.char, char, char)
363 |     endfor
364 |   endfor
365 | 
366 |   for mode in ['i', 'c']
367 |     silent! call M(mode, map_modifier.' '.'<C-h>', '<BS>', '<C-h>')
368 |     silent! call M(mode, map_modifier.' '.'<Return>', '<Enter>', '<Return>')
369 |     silent! call M(mode, map_modifier.' '.'<C-m>', '<Enter>', '<C-m>')
370 |     silent! call M(mode, map_modifier.' '.'<CR>', '<Enter>', '<CR>')
371 |     silent! call M(mode, map_modifier.' '.'<C-j>', '<Enter>', '<C-j>')
372 |     silent! call M(mode, map_modifier.' '.'<NL>', '<Enter>', '<NL>')
373 |   endfor
374 | endfunction
375 | 
376 | 
377 | 
378 | 
379 | "{{{2
380 | 
381 | 
382 | 
383 | 
384 | " Misc.  "{{{1
385 | function! smartinput#invoke_the_initial_setup_if_necessary()  "{{{2
386 |   " The initial setup is invoked implicitly by :source'ing the autoload file.
387 |   " So that this function does nothing explicitly.
388 | endfunction
389 | 
390 | 
391 | 
392 | 
393 | function! smartinput#scope()  "{{{2
394 |   return s:
395 | endfunction
396 | 
397 | 
398 | 
399 | 
400 | function! smartinput#sid()  "{{{2
401 |   return maparg('<SID>', 'n')
402 | endfunction
403 | nnoremap <SID>  <SID>
404 | 
405 | 
406 | 
407 | 
408 | function! s:calculate_rule_priority(snrule)  "{{{2
409 |   return
410 |   \ len(a:snrule.at)
411 |   \ + (a:snrule.filetype is 0 ? 0 : 100 / len(a:snrule.filetype))
412 |   \ + (a:snrule.syntax is 0 ? 0 : 100 / len(a:snrule.syntax))
413 |   \ + 100 / len(a:snrule.mode)
414 | endfunction
415 | 
416 | 
417 | 
418 | 
419 | function! s:decode_key_notation(s)  "{{{2
420 |   return eval('"' . escape(a:s, '<"\') . '"')
421 | endfunction
422 | 
423 | 
424 | 
425 | 
426 | function! s:find_the_most_proper_rule_in_command_line_mode(nrules, char, cl_text, cl_column, cl_type)  "{{{2
427 |   " FIXME: Optimize for speed if necessary.
428 | 
429 |   let column = a:cl_column - 1
430 |   let cl_text = (column == 0 ? '' : a:cl_text[:(column - 1)])
431 |   \             . s:UNTYPABLE_CHAR
432 |   \             . a:cl_text[(column):]
433 | 
434 |   for nrule in a:nrules
435 |     if stridx(nrule.mode, a:cl_type) == -1
436 |       continue
437 |     endif
438 | 
439 |     if !(a:char ==# nrule._char)
440 |       continue
441 |     endif
442 | 
443 |     " FIXME: Replace \%# correctly.
444 |     " For example, if nrule.at is '\\%#', it should not be replaced.
445 |     if cl_text !~# substitute(nrule.at, '\\%#', s:UNTYPABLE_CHAR, 'g')
446 |       continue
447 |     endif
448 | 
449 |     return nrule
450 |   endfor
451 | 
452 |   return 0
453 | endfunction
454 | 
455 | let s:UNTYPABLE_CHAR = "\x01"  " FIXME: Use a more proper value.
456 | 
457 | 
458 | 
459 | 
460 | function! s:find_the_most_proper_rule_in_insert_mode(nrules, char)  "{{{2
461 |   " FIXME: Optimize for speed if necessary.
462 |   let syntax_names = map(synstack(line('.'), col('.')),
463 |   \                      'synIDattr(synIDtrans(v:val), "name")')
464 | 
465 |   for nrule in a:nrules
466 |     if stridx(nrule.mode, 'i') == -1
467 |       continue
468 |     endif
469 | 
470 |     if !(a:char ==# nrule._char)
471 |       continue
472 |     endif
473 | 
474 |     if !(search(nrule.at, 'bcnW'))
475 |       continue
476 |     endif
477 | 
478 |     if !(nrule.filetype is 0
479 |     \    ? !0
480 |     \    : 0 <= index(nrule.filetype,  &l:filetype))
481 |       continue
482 |     endif
483 | 
484 |     if !(nrule.syntax is 0
485 |     \    ? !0
486 |     \    : 0 <= max(map(copy(nrule.syntax), 'index(syntax_names, v:val)')))
487 |       continue
488 |     endif
489 | 
490 |     return nrule
491 |   endfor
492 | 
493 |   return 0
494 | endfunction
495 | 
496 | 
497 | 
498 | 
499 | function! s:insert_or_replace_a_rule(sorted_nrules, nrule)  "{{{2
500 |   " a:sorted_nrules MUST be sorted by "hash" in descending order.
501 |   " So that binary search can be applied
502 |   "
503 |   " * To replace an existing rule which is equivalent to a:nrule, and
504 |   " * To insert a:nrule at the proper position to make the resulting
505 |   "   a:sorted_nrules sorted.
506 | 
507 |   let i_min = 0
508 |   let i_max = len(a:sorted_nrules) - 1
509 |   let i_med = 0
510 | 
511 |   while i_min <= i_max
512 |     let i_med = (i_min + i_max) / 2
513 | 
514 |     if a:nrule.hash ==# a:sorted_nrules[i_med].hash
515 |       break
516 |     elseif !(a:nrule.hash <# a:sorted_nrules[i_med].hash)
517 |       let i_max = i_med - 1
518 |     else
519 |       let i_min = i_med + 1
520 |     endif
521 |   endwhile
522 | 
523 |   if i_min <= i_max
524 |     " The same rule is found at i_med.
525 |     let a:sorted_nrules[i_med] = a:nrule
526 |   elseif i_max < i_med
527 |     " The same rule is not found,
528 |     " but it should be located between i_max and i_med.
529 |     call insert(a:sorted_nrules, a:nrule, i_med + 0)
530 |   else  " i_med < i_min
531 |     " The same rule is not found,
532 |     " but it should be located between i_med and i_min.
533 |     call insert(a:sorted_nrules, a:nrule, i_med + 1)
534 |   endif
535 | endfunction
536 | 
537 | 
538 | 
539 | 
540 | function! s:normalize_rule(urule)  "{{{2
541 |   let nrule = deepcopy(a:urule)
542 | 
543 |   let nrule._char = s:decode_key_notation(nrule.char)
544 | 
545 |   let nrule._input = s:decode_key_notation(nrule.input)
546 | 
547 |   if !has_key(nrule, 'mode')
548 |     let nrule.mode = 'i'
549 |   endif
550 | 
551 |   if has_key(nrule, 'filetype')
552 |     call sort(nrule.filetype)
553 |   else
554 |     let nrule.filetype = 0
555 |   endif
556 | 
557 |   if has_key(nrule, 'syntax')
558 |     call sort(nrule.syntax)
559 |   else
560 |     let nrule.syntax = 0
561 |   endif
562 | 
563 |   let nrule.priority =  s:calculate_rule_priority(nrule)
564 | 
565 |   let nrule.hash = string([
566 |   \   printf('%06d', nrule.priority),
567 |   \   nrule.at,
568 |   \   nrule.char,
569 |   \   nrule.filetype,
570 |   \   nrule.syntax
571 |   \ ])
572 | 
573 |   return nrule
574 | endfunction
575 | 
576 | 
577 | 
578 | 
579 | function! s:sid_value()  "{{{2
580 |   return substitute(smartinput#sid(), '<SNR>', "\<SNR>", 'g')
581 | endfunction
582 | 
583 | 
584 | 
585 | 
586 | "{{{2
587 | 
588 | 
589 | 
590 | 
591 | " The initial setup  "{{{1
592 | function! s:do_initial_setup()  "{{{2
593 |   call smartinput#define_default_rules()
594 | 
595 |   if !exists('g:smartinput_no_default_key_mappings')
596 |     call smartinput#map_trigger_keys()
597 |   endif
598 | endfunction
599 | 
600 | 
601 | 
602 | 
603 | " Invoke the initial setup.  "{{{2
604 | 
605 | if !exists('s:loaded_count')
606 |   let s:loaded_count = 0
607 | endif
608 | 
609 | let s:loaded_count += 1
610 | 
611 | if s:loaded_count == 1
612 |   call s:do_initial_setup()
613 | endif
614 | 
615 | 
616 | 
617 | 
618 | "{{{2
619 | 
620 | 
621 | 
622 | 
623 | " __END__  "{{{1
624 | " vim: foldmethod=marker
625 | 


--------------------------------------------------------------------------------
/doc/smartinput.txt:
--------------------------------------------------------------------------------
  1 | *smartinput.txt*	Provide smart input assistant
  2 | 
  3 | Version 0.1.0
  4 | Copyright (C) 2012-2018 Kana Natsuno <http://whileimautomaton.net/>
  5 | License: MIT license  {{{
  6 |     Permission is hereby granted, free of charge, to any person obtaining
  7 |     a copy of this software and associated documentation files (the
  8 |     "Software"), to deal in the Software without restriction, including
  9 |     without limitation the rights to use, copy, modify, merge, publish,
 10 |     distribute, sublicense, and/or sell copies of the Software, and to
 11 |     permit persons to whom the Software is furnished to do so, subject to
 12 |     the following conditions:
 13 | 
 14 |     The above copyright notice and this permission notice shall be included
 15 |     in all copies or substantial portions of the Software.
 16 | 
 17 |     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |     OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 19 |     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 20 |     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 21 |     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 22 |     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 23 |     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 24 | }}}
 25 | 
 26 | CONTENTS					*smartinput-contents*
 27 | 
 28 | Introduction            |smartinput-introduction|
 29 | Interface               |smartinput-interface|
 30 |   Functions               |smartinput-functions|
 31 |   Key Mappings            |smartinput-key-mappings|
 32 | Rules                   |smartinput-rules|
 33 | Customization           |smartinput-customization|
 34 | Bugs                    |smartinput-bugs|
 35 | Changelog               |smartinput-changelog|
 36 | 
 37 | 
 38 | 
 39 | 
 40 | ==============================================================================
 41 | INTRODUCTION					*smartinput-introduction*
 42 | 
 43 | *smartinput* is a Vim plugin to provide smart input assistant.
 44 | Whenever you write a text, especially source code, you have to input and deal
 45 | with pairs of punctuations such as (), [], {}, and so on.  This plugin
 46 | provides various input assistants for such characters according to the current
 47 | context by default, and you can define your own rules to how the smart input
 48 | assistant behaves in Insert mode and Command-line mode.
 49 | 
 50 | For example, this plugin provides the following rules by default
 51 | (note that "#" indicates the cursor position in the following examples):
 52 | 
 53 | Complete the corresponding character automatically:
 54 | 
 55 |    Before | Input | After   ~
 56 |    -------+-------+-------- ~
 57 |    #      | (     | (#)
 58 |    #      | {     | {#}
 59 |    #      | "     | "#"
 60 | 
 61 | Leave from the current block easily:
 62 | 
 63 |    Before | Input | After   ~
 64 |    -------+-------+-------- ~
 65 |    (#)    | )     | ()#
 66 |    [#]    | ]     | []#
 67 |    "foo#" | "     | "foo"#
 68 | 
 69 | Undo the completion easily:
 70 | 
 71 |    Before | Input | After   ~
 72 |    -------+-------+-------- ~
 73 |    (#)    | <BS>  | #
 74 |    ()#    | <BS>  | #
 75 | 
 76 | Care to input strings and regular expressions:
 77 | 
 78 |    Before | Input | After   ~
 79 |    -------+-------+-------- ~
 80 |    \#     | "     | \"#
 81 |    \#     | <     | \<#
 82 | 
 83 | Care to input English words:
 84 | 
 85 |    Before | Input | After   ~
 86 |    -------+-------+-------- ~
 87 |    let#   | 's    | let's#
 88 |    foo(#  | '     | foo('#'
 89 | 
 90 | Care to write Lisp/Scheme source code:
 91 | 
 92 |    Before | Input | After   ~
 93 |    -------+-------+-------- ~
 94 |    #      | 'foo  | 'foo#
 95 |    "#"    | 'hi   | "'hi#'"
 96 | 
 97 | Care to write C-like syntax source code:
 98 | 
 99 |    Before       | Input   | After        ~
100 |    -------------+---------+------------- ~
101 |    if (...) {#} | <Enter> | if (...) {
102 |                 |         |     #
103 | 		|         | }
104 |    if (...)     | <Enter> | if (...)
105 |    {#}          |         | {
106 | 		|         |     #
107 | 		|         | }
108 | 
109 | 
110 | Requirements:
111 | - Vim 7.3 or later
112 | 
113 | Latest version:
114 | https://github.com/kana/vim-smartinput
115 | 
116 | Document in HTML format:
117 | http://vim-doc.heroku.com/view?https://github.com/kana/vim-smartinput/blob/master/doc/smartinput.txt
118 | 
119 | 
120 | 
121 | 
122 | ==============================================================================
123 | INTERFACE					*smartinput-interface*
124 | 
125 | ------------------------------------------------------------------------------
126 | FUNCTIONS					*smartinput-functions*
127 | 
128 | smartinput#clear_rules()			*smartinput#clear_rules()*
129 | 			Clear all defined rules.
130 | 
131 | smartinput#define_default_rules()	   *smartinput#define_default_rules()*
132 | 			Define |smartinput-default-rules|.
133 | 
134 | smartinput#define_rule({rule})			*smartinput#define_rule()*
135 | 			Define a rule for the smart input assistant.
136 | 			See |smartinput-rules| for the details of {rule}.
137 | 
138 | 						*smartinput#map_to_trigger()*
139 | smartinput#map_to_trigger({mode}, {lhs}, {rhs-char}, {rhs-fallback})
140 | 			Map {lhs} to trigger the smart input assistant for
141 | 			{rhs-char} in {mode}.  If there is no proper rule
142 | 			for the current context, {rhs-fallback} will be
143 | 			inserted instead of {lhs}.
144 | 
145 | 			{lhs}, {rhs-char} and {rhs-fallback} are strings to
146 | 			denote key sequences.
147 | 
148 | 			{lhs} is mapped in Insert mode if {mode} is 'i'.
149 | 			{lhs} is mapped in Command-line mode if {mode} is 'c'.
150 | 
151 | 			See also |smartinput-customization| for the details.
152 | 
153 | smartinput#map_trigger_keys([{overridep}])     *smartinput#map_trigger_keys()*
154 | 			Map keys to trigger smart input assistant according to
155 | 			rules which are currently defined.
156 | 			Existing key mappings are overridden if {overridep} is
157 | 			true, otherwise existing key mappings are kept.
158 | 			If {overridep} is omitted, it is treated as a false
159 | 			value.
160 | 
161 | 
162 | ------------------------------------------------------------------------------
163 | KEY MAPPINGS					*smartinput-key-mappings*
164 | 
165 | Several characters in Insert mode and Command-line mode are mapped by default
166 | with |smartinput#map_to_trigger()| to trigger the smart input assistant.
167 | See |smartinput-default-rules| for the details.
168 | 
169 | Set any value to *g:smartinput_no_default_key_mappings*
170 | if you don't want to define the default key mappings.
171 | 
172 | Each default key mapping will not be defined if the {lhs} is already mapped to
173 | something.  For example, the default key mapping on "(" will not be defined if
174 | you map "(" to something in your vimrc.
175 | 
176 | Set non-zero to *g:smartinput_break_undo*
177 | if you want to undo or redo in small units.
178 | 
179 | 
180 | 
181 | 
182 | ==============================================================================
183 | RULES						*smartinput-rules*
184 | 
185 | ------------------------------------------------------------------------------
186 | RULE DEFINITION					*smartinput-rule-definition*
187 | 
188 | Smart input assistants are defined by "rules".  Each "rule" is represented as
189 | a |Dictionary| which contains the following items:
190 | 
191 | "at" (string) (required)
192 | 	Specifies the context to use the smart input assistant.
193 | 	This value is treated as a |regular-expression|.
194 | 	The smart input assistant will be used if the regular expression
195 | 	matches to the cursor position.
196 | 
197 | 	Tips: You can use |/\%#| to indicate the cursor position.
198 | 	For example, '(\%#)' means that the smart input assistant will be used
199 | 	if the cursor is located between parentheses.
200 | 
201 | 	Though |/\%#| works only for matching with the current buffer,
202 | 	you can still use it for "at" to specify the cursor position in
203 | 	Command-line mode.
204 | 
205 | "char" (string) (required)
206 | 	Specifies a character to trigger the smart input assistant.
207 | 	See also |smartinput-special-keys|.
208 | 
209 | "input" (string) (required)
210 | 	Specifies a result of the smart input assistant.
211 | 	This value is used like {rhs} for |:map| commands.
212 | 	This value is inputted instead of the "char" value.
213 | 	See also |smartinput-special-keys|.
214 | 
215 | "mode" (string) (optional)
216 | 	Specifies the context to use the smart input assistant.
217 | 	This value is a string of characters to represent modes in which the
218 | 	smart input assistant will be used.  Valid characters and
219 | 	corresponding modes are as follows:
220 | 
221 | 	Character	Mode			~
222 | 	---------	-----------------	~
223 | 	i		Insert mode
224 | 	:		Command-line mode for normal Ex commands
225 | 	>		Command-line mode for |debug-mode| commands
226 | 	/		Command-line mode for searching with |/|
227 | 	?		Command-line mode for searching with |?|
228 | 	@		Command-line mode for |input()|
229 | 	-		Command-line mode for |:insert| or |:append|
230 | 
231 | 	The default value is 'i'.
232 | 
233 | "filetype" (list of strings) (optional)
234 | 	Specifies the context to use the smart input assistant.
235 | 	This value is a list of 'filetype' names like "lisp", "scheme" etc.
236 | 	The smart input assistant will be used if:
237 | 	
238 | 	- This item is not given, or
239 | 	- The current buffer's 'filetype' equals one of this value.
240 | 
241 | 	If 'filetype' is a compound one which has two or more names
242 | 	concatenated by ".", each name will be tested instead of the whole
243 | 	value of 'filetype'.
244 | 
245 | 	This specification works only for Insert mode.
246 | 
247 | "syntax" (list of strings) (optional)
248 | 	Specifies the context to use the smart input assistant.
249 | 	This value is a list of syntax names like "Comment", "Constant" etc.
250 | 	The smart input assistant will be used if:
251 | 	
252 | 	- This item is not given, or
253 | 	- The cursor position is highlighted as one of this value.
254 | 
255 | 	See also |group-name| for examples of available values.
256 | 	See also |smartinput-check-syntax-highlighting|.
257 | 
258 | 	Note that only "wide" syntax items are effective.  In other words,
259 | 	syntax items which is linked to another is not effective, and they
260 | 	will never be matched.  For example:
261 | 
262 | 	* "Constant" is effective because it is not linked to anything.
263 | 	* "String" is not effective because it is linked to "Constant".
264 | 	* "lispString" is not effective because it is linked to "String".
265 | 
266 | 	This specification works only for Insert mode.
267 | 
268 | 						*smartinput-special-keys*
269 | Values of "char" and "input" are internally passed to |:map| commands.  So
270 | that:
271 | 
272 | - Special keys must be written like '<Left>', not "\<Left>".
273 | - "|" must be written '<Bar>'.
274 | - "\" must be written '<Bslash>'.
275 | 
276 | 					*smartinput-check-syntax-highlighting*
277 | To investigate how the character under the cursor is highlighted, use the
278 | following command:
279 | >
280 |   echo map(synstack(line('.'),col('.')),'synIDattr(synIDtrans(v:val),"name")')
281 | <
282 | 
283 | 
284 | ------------------------------------------------------------------------------
285 | DEFAULT RULES					*smartinput-default-rules*
286 | 
287 | For convenience, there are many rules defined by default.  And it's hard to
288 | list and to describe each rule here, because the default rules will be often
289 | updated.
290 | 
291 | See |smartinput-introduction| for a short digest of the default rules.
292 | 
293 | See the source code of |smartinput#define_default_rules()| for the details:
294 | - If you read this document in Vim,
295 |   open ../autoload/smartinput.vim (type |gf| at the file name).
296 | - If you read this document with a Web browser, open the following:
297 |   https://github.com/kana/vim-smartinput/blob/master/autoload/smartinput.vim
298 | 
299 | 
300 | ------------------------------------------------------------------------------
301 | PRIORITIES					*smartinput-rule-priorities*
302 | 
303 | Rules have priorities.  It is used to select the best rule for the smart input
304 | assistant.
305 | 
306 | Rule priorities are calculated as follows:
307 | 
308 | (a) "at" length.
309 | (b) 100 / {the number of elements} if "filetype" is given.
310 |     0 if "filetype" is not given.
311 | (c) 100 / {the number of elements} if "syntax" is given.
312 |     0 if "syntax" is not given.
313 | (d) 100 / {the length of "mode"}.
314 | 
315 | Rule priority = (a) + (b) + (c) + (d)
316 | 
317 | For example:
318 | 
319 | 	{'at': '\%#', 'char': "'", 'input': "''\<Left>"} ~
320 | 		(a) 3
321 | 		(b) 0
322 | 		(c) 0
323 | 		(d) 100 / 1 = 100
324 | 		Priority = 3 + 0 + 0 + 100 = 103
325 | 
326 | 	{'at': '\%#', 'char': "'", 'input': "'", ~
327 | 	 'filetype': ['lisp', 'scheme']} ~
328 | 		(a) 3
329 | 		(b) 100 / 2 = 50
330 | 		(c) 0
331 | 		(d) 100 / 1 = 100
332 | 		Priority = 3 + 50 + 0 + 100 = 153
333 | 
334 | 	{'at': '\%#', 'char': "'", 'input': "'", ~
335 | 	 'filetype': ['lisp', 'scheme'], ~
336 | 	 'syntax': ['Comment', 'Constant']} ~
337 | 		(a) 3
338 | 		(b) 100 / 2 = 50
339 | 		(c) 100 / 2 = 50
340 | 		(d) 100 / 1 = 100
341 | 		Priority = 3 + 50 + 50 + 100 = 203
342 | 
343 | 
344 | ------------------------------------------------------------------------------
345 | RULE SELECTION ALGORITHM		 *smartinput-rule-selection-algorithm*
346 | 
347 | Whenever you type a key in Insert mode or Command-line mode, the plugin
348 | selects the best rule for the current context with the following steps:
349 | 
350 | (1) Select available rules which satisfy all the following conditions:
351 | 
352 |     (c) "char" value is equal to the typed key.
353 |     (a) The text under the cursor is matched to "at" pattern.
354 |     (f) The 'filetype' of the current buffer is contained in "filetype" list,
355 |         or "filetype" list is omitted,
356 | 	or the current mode is not Insert mode.
357 |     (s) The character at the cursor is highlighted as one of "syntax" names,
358 |         or "syntax" names are omitted,
359 | 	or the current mode is not Insert mode.
360 |     (m) The current mode matches to "mode" value.
361 | 
362 | (2) If two or more rules are selected at the step (1),
363 |     select the rule with the highest |smartinput-rule-priority|.
364 | 
365 | (3) If two or more rules are selected at the step (2),
366 |     select the rule with the greatest "at".
367 |     Note that this step is just to avoid unstable selection.
368 | 
369 | 
370 | ------------------------------------------------------------------------------
371 | RULE CONVENTIONS				*smartinput-rule-conventions*
372 | 
373 | Like |i_<BS>| and |i_CTRL-H|, there are several keys which does the same
374 | effects.  If you want to define rules for such keys,
375 | 
376 | * Use the most descriptive keys for "char"s of rules.
377 | * Map other keys to trigger rules for the descriptive keys.
378 | 
379 | For example, if you want to define rules on both |i_<BS>| and |i_CTRL-H|,
380 | 
381 | * Define rules only for <BS>.
382 | * Map <C-h> to trigger rules for <BS>, with the following command:
383 | >
384 | 	smartinput#map_to_trigger('<C-h>', '<BS>', '<C-h>')
385 | <
386 | This convention is to avoid rule duplication.  See also the following table:
387 | 
388 | "char" keys | Mapped keys                    ~
389 | ------------+------------------------------- ~
390 | <BS>        | <C-h>
391 | <Enter>     | <C-m> <C-j> <CR> <NL> <Return>
392 | <Esc>       | <C-[>
393 | <Tab>       | <C-i>
394 | 
395 | 
396 | 
397 | 
398 | ==============================================================================
399 | CUSTOMIZATION					*smartinput-customization*
400 | 
401 | 						*smartinput-customization-a*
402 | (A) To define your own |smartinput-rules| for the smart input assistant,
403 |     use |smartinput#define_rule()|.  See also |smartinput-default-rules| for
404 |     the real world examples.
405 | 
406 | 						*smartinput-customization-b*
407 | (B) If you define your own |smartinput-rules| which "char" values are
408 |     different from ones of |smartinput-default-rules|, you have to define
409 |     trigger keys for your own rules with |smartinput#map_to_trigger()| or
410 |     |smartinput#map_trigger_keys()|.
411 | 
412 | 						*smartinput-customization-c*
413 | (C) Example #1: If you often write Ruby script and you want to insert "#{}"
414 |     by typing "#" in a string literal to input string interpolation easily,
415 |     add the following lines into your |vimrc|:
416 | >
417 |     call smartinput#map_to_trigger('i', '#', '#', '#')
418 |     call smartinput#define_rule({
419 |     \   'at': '\%#',
420 |     \   'char': '#',
421 |     \   'input': '#{}<Left>',
422 |     \   'filetype': ['ruby'],
423 |     \   'syntax': ['Constant', 'Special'],
424 |     \ })
425 | <
426 | 						*smartinput-customization-d*
427 | (D) Example #2: If you often write Ruby script and you want to insert "||"
428 |     by typing "|" to declare block-local variable easily,
429 |     add the following lines into your |vimrc|:
430 | >
431 |     call smartinput#map_to_trigger('i', '<Bar>', '<Bar>', '<Bar>')
432 |     call smartinput#define_rule({
433 |     \   'at': '\%#',
434 |     \   'char': '<Bar>',
435 |     \   'input': '<Bar><Bar><Left>',
436 |     \   'filetype': ['ruby'],
437 |     \ })
438 | <
439 |     But the above rule is not so useful, because "||" is always inserted and
440 |     the cursor is moved into the bars, even if you want to write the following
441 |     idiom: "foo ||= bar".  So that it's better to tweak the "at" value to
442 |     activate the rule if and only if the cursor is just after "{" or "do":
443 | >
444 |     call smartinput#define_rule({
445 |     \   'at': '\({\|\<do\>\)\s*\%#',
446 |     \   'char': '<Bar>',
447 |     \   'input': '<Bar><Bar><Left>',
448 |     \   'filetype': ['ruby'],
449 |     \ })
450 | <
451 | 
452 | 
453 | 
454 | ==============================================================================
455 | BUGS						*smartinput-bugs*
456 | 
457 | - Still this plugin is not mature, there might be problematic behavior and
458 |   missing features.  If you find any problem or have any suggestion, please
459 |   give your feedback to the author via:
460 |   https://github.com/kana/vim-smartinput/issues
461 | 
462 | 				   *smartinput-disable-completion-temporarily*
463 | - Though there are many default rules to support user input naturally, the
464 |   smart input assistant is not perfect.  It sometimes completes quotes etc
465 |   where such completion is not necessary.  In that case, use |i_CTRL-V| to
466 |   input a character solely.  For example, type "<C-v>(" to input only "(".
467 | 
468 | 					    *smartinput-backspace-requirement*
469 | - Several rules require that 'backspace' is set to "indent,eol,start" or 2.
470 | 
471 | 
472 | 
473 | 
474 | ==============================================================================
475 | CHANGELOG					*smartinput-changelog*
476 | 
477 | 0.1.0	2018-03-22T19:29:34+09:00		*smartinput-changelog-0.1.0*
478 |         - Update some |smartinput-default-rules| to not break undo by default
479 |           for Vim 8.0 or later.  See also |g:smartinput_break_undo|.
480 | 
481 | 0.0.5	2012-04-11T21:48:41+09:00		*smartinput-changelog-0.0.5*
482 | 	- Fix rules to leave from a (), [], or {} block.  They did not work
483 | 	  properly with Visual-block Insert (|v_b_I|), etc.  Thanks to Dennis
484 | 	  Sjögren for reporting the problem.
485 | 	- Fix rules to expand a () or {} block.  After expanding a block,
486 | 	  <Esc> had to be typed twice to return to Normal mode.  Thanks to
487 | 	  Jonas Haag for reporting the problem.
488 | 
489 | 0.0.4	2012-04-07T16:26:23+09:00		*smartinput-changelog-0.0.4*
490 | 	- Add rules for Clojure.  Thanks to Bodaniel Jeanes for the feedback.
491 | 	- Add rules for Python-specific string literals such as r'...'.
492 | 	  Thanks to Adrian Sampson for the initial rules and the ideas.
493 | 	- Add examples to write custom rules.
494 | 	  See |smartinput-customization-c| and |smartinput-customization-d|
495 | 	  for the details.  Thanks to Guillaume for the feedback.
496 | 
497 | 0.0.3	2012-04-04T21:33:34+09:00		*smartinput-changelog-0.0.3*
498 | 	- Revise rules for expanding {} and () blocks to indent correctly for
499 | 	  some 'filetype's, especially for PHP.  Thanks to Jon Duell for the
500 | 	  feedback on this problem.
501 | 	- Add a note on how to disable completion temporarily.
502 | 	  See |smartinput-disable-completion-temporarily| for the details.
503 | 	- Add a note on 'backspace'.  See |smartinput-backspace-requirement|.
504 | 
505 | 0.0.2	2012-04-01T16:11:14+09:00		*smartinput-changelog-0.0.2*
506 | 	- Revise the default rules to easily leave from multiline {}, [] and
507 | 	  () blocks.  Thanks to Curtis McEnroe for the suggestion.
508 | 	- Revise the default rules for escaped ' and rules to leave from a ''
509 | 	  block.  The former is used by default, and the latter is used only
510 | 	  for specific languages which \ doesn't have special meanings in ''
511 | 	  blocks, for example, Perl, Ruby, shell script and Vim script.
512 | 	  Thanks to Andrew Ray for the suggestion.
513 | 
514 | 0.0.1	2012-03-30T19:38:53+09:00		*smartinput-changelog-0.0.1*
515 | 	- Fix side effects in the default configuration.  <C-h> in
516 | 	  Command-line mode did not update the screen immediately.
517 | 	- Add the default rules to input triple quotes such as '''...''',
518 | 	  """...""" and ```...```, for Python, Markdown, etc.
519 | 	- Add the default rules to easily comment to edit Vim script.  Because
520 | 	  |:comment| in Vim script starts with " while string literals are
521 | 	  quoted with ".  Now " is completed only if the current context is to
522 | 	  input string literals.
523 | 
524 | 0.0.0	2012-02-09T22:35:02+09:00		*smartinput-changelog-0.0.0*
525 | 	- Initial version.
526 | 
527 | 
528 | 
529 | 
530 | ==============================================================================
531 | vim:tw=78:ts=8:ft=help:norl:fen:fdl=0:fdm=marker:
532 | 


--------------------------------------------------------------------------------
/plugin/smartinput.vim:
--------------------------------------------------------------------------------
 1 | " smartinput - Provide smart input assistant
 2 | " Version: 0.1.0
 3 | " Copyright (C) 2012-2018 Kana Natsuno <http://whileimautomaton.net/>
 4 | " License: MIT license  {{{
 5 | "     Permission is hereby granted, free of charge, to any person obtaining
 6 | "     a copy of this software and associated documentation files (the
 7 | "     "Software"), to deal in the Software without restriction, including
 8 | "     without limitation the rights to use, copy, modify, merge, publish,
 9 | "     distribute, sublicense, and/or sell copies of the Software, and to
10 | "     permit persons to whom the Software is furnished to do so, subject to
11 | "     the following conditions:
12 | "
13 | "     The above copyright notice and this permission notice shall be included
14 | "     in all copies or substantial portions of the Software.
15 | "
16 | "     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 | "     OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | "     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | "     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | "     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | "     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | "     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | " }}}
24 | 
25 | if exists('g:loaded_smartinput')
26 |   finish
27 | endif
28 | 
29 | 
30 | 
31 | 
32 | call smartinput#invoke_the_initial_setup_if_necessary()
33 | 
34 | 
35 | 
36 | 
37 | let g:loaded_smartinput = 1
38 | 
39 | " __END__
40 | " vim: foldmethod=marker
41 | 


--------------------------------------------------------------------------------
/t/api.vim:
--------------------------------------------------------------------------------
   1 | " NB: MacVim defines several key mappings such as <D-v> by default.
   2 | " The key mappings are defined from the core, not from any runtime file.
   3 | " So that the key mappings are always defined even if Vim is invoked by
   4 | " "vim -u NONE" etc.  Remove the kay mappings to ensure that there is no key
   5 | " mappings, because some tests in this file assume such state.
   6 | imapclear
   7 | 
   8 | runtime! plugin/smartinput.vim
   9 | 
  10 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
  11 | set backspace=indent,eol,start
  12 | filetype plugin indent on
  13 | syntax enable
  14 | 
  15 | describe 'smartinput#clear_rules'
  16 |   before
  17 |     SaveContext
  18 |     new
  19 |     let b:uruleA = {
  20 |     \   'at': '\%#',
  21 |     \   'char': '(',
  22 |     \   'input': '()<Left>',
  23 |     \   'filetype': ['foo', 'bar', 'baz'],
  24 |     \   'syntax': ['String', 'Comment'],
  25 |     \ }
  26 |     let b:nruleA = Call('s:normalize_rule', b:uruleA)
  27 |     let b:uruleB = {
  28 |     \   'at': '\%#',
  29 |     \   'char': '[',
  30 |     \   'input': '[]<Left>',
  31 |     \   'filetype': ['foo', 'bar'],
  32 |     \   'syntax': ['String', 'Comment'],
  33 |     \ }
  34 |     let b:nruleB = Call('s:normalize_rule', b:uruleB)
  35 |   end
  36 | 
  37 |   after
  38 |     close
  39 |     ResetContext
  40 |   end
  41 | 
  42 |   it 'should clear all defined rules'
  43 |     " Because of the default configuration.
  44 |     Expect Ref('s:available_nrules') !=# []
  45 | 
  46 |     call smartinput#clear_rules()
  47 |     Expect Ref('s:available_nrules') ==# []
  48 | 
  49 |     call smartinput#define_rule(b:uruleA)
  50 |     Expect Ref('s:available_nrules') ==# [b:nruleA]
  51 | 
  52 |     call smartinput#define_rule(b:uruleB)
  53 |     Expect Ref('s:available_nrules') ==# [b:nruleB, b:nruleA]
  54 | 
  55 |     call smartinput#clear_rules()
  56 |     Expect Ref('s:available_nrules') ==# []
  57 |   end
  58 | end
  59 | 
  60 | describe 'smartinput#define_default_rules'
  61 |   before
  62 |     SaveContext
  63 |   end
  64 | 
  65 |   after
  66 |     ResetContext
  67 |   end
  68 | 
  69 |   it 'should define many rules'
  70 |     call smartinput#clear_rules()
  71 |     Expect Ref('s:available_nrules') ==# []
  72 | 
  73 |     call smartinput#define_default_rules()
  74 |     Expect Ref('s:available_nrules') !=# []
  75 |   end
  76 | 
  77 |   it 'should override existing rules if conflicted'
  78 |     call smartinput#clear_rules()
  79 |     Expect Ref('s:available_nrules') ==# []
  80 | 
  81 |     call smartinput#define_rule({'at': 'x\%#', 'char': '(', 'input': '---'})
  82 |     call smartinput#define_rule({'at': '\%#', 'char': '(', 'input': '---'})
  83 |     Expect len(Ref('s:available_nrules')) == 2
  84 | 
  85 |     let unconflicted_nrule = Ref('s:available_nrules')[0]
  86 |     let conflicted_nrule = Ref('s:available_nrules')[1]
  87 |     Expect unconflicted_nrule.at ==# 'x\%#'
  88 |     Expect conflicted_nrule.at ==# '\%#'
  89 | 
  90 |     call smartinput#define_default_rules()
  91 |     Expect Ref('s:available_nrules') !=# []
  92 |     Expect index(Ref('s:available_nrules'), unconflicted_nrule) != -1
  93 |     Expect index(Ref('s:available_nrules'), conflicted_nrule) == -1
  94 |   end
  95 | 
  96 |   " The behavior of each rules are tested
  97 |   " in 'The default configuration' block.
  98 | end
  99 | 
 100 | describe 'smartinput#define_rule'
 101 |   before
 102 |     SaveContext
 103 |     new
 104 |     let b:uruleA = {
 105 |     \   'at': '\%#',
 106 |     \   'char': '(',
 107 |     \   'input': '()<Left>',
 108 |     \   'filetype': ['foo', 'bar', 'baz'],
 109 |     \   'syntax': ['String', 'Comment'],
 110 |     \ }
 111 |     let b:nruleA = Call('s:normalize_rule', b:uruleA)
 112 |     let b:uruleB = {
 113 |     \   'at': '\%#',
 114 |     \   'char': '[',
 115 |     \   'input': '[]<Left>',
 116 |     \   'filetype': ['foo', 'bar'],
 117 |     \   'syntax': ['String', 'Comment'],
 118 |     \ }
 119 |     let b:nruleB = Call('s:normalize_rule', b:uruleB)
 120 |     let b:uruleBd = {
 121 |     \   'at': '\%#',
 122 |     \   'char': '[',
 123 |     \   'input': '[  ]<Left><Left>',
 124 |     \   'filetype': ['foo', 'bar'],
 125 |     \   'syntax': ['String', 'Comment'],
 126 |     \ }
 127 |     let b:nruleBd = Call('s:normalize_rule', b:uruleBd)
 128 |     let b:uruleC1 = {
 129 |     \   'at': ' + \%#',
 130 |     \   'char': '+',
 131 |     \   'input': '<BS><BS><BS>++',
 132 |     \ }
 133 |     let b:nruleC1 = Call('s:normalize_rule', b:uruleC1)
 134 |     let b:uruleC2 = {
 135 |     \   'at': '\S \%#',
 136 |     \   'char': '+',
 137 |     \   'input': '+ ',
 138 |     \ }
 139 |     let b:nruleC2 = Call('s:normalize_rule', b:uruleC2)
 140 |   end
 141 | 
 142 |   after
 143 |     close
 144 |     ResetContext
 145 |   end
 146 | 
 147 |   it 'should define a new rule in the global state'
 148 |     " Because of the default configuration.
 149 |     Expect Ref('s:available_nrules') !=# []
 150 | 
 151 |     call Set('s:available_nrules', [])
 152 |     Expect Ref('s:available_nrules') ==# []
 153 | 
 154 |     call smartinput#define_rule(b:uruleA)
 155 |     Expect Ref('s:available_nrules') ==# [b:nruleA]
 156 | 
 157 |     call smartinput#define_rule(b:uruleB)
 158 |     Expect Ref('s:available_nrules') ==# [b:nruleB, b:nruleA]
 159 |   end
 160 | 
 161 |   it 'should not define two or more "same" rules'
 162 |     " Because of the default configuration.
 163 |     Expect Ref('s:available_nrules') !=# []
 164 | 
 165 |     call Set('s:available_nrules', [])
 166 |     Expect Ref('s:available_nrules') ==# []
 167 | 
 168 |     call smartinput#define_rule(b:uruleA)
 169 |     Expect Ref('s:available_nrules') ==# [b:nruleA]
 170 | 
 171 |     call smartinput#define_rule(b:uruleA)
 172 |     Expect Ref('s:available_nrules') ==# [b:nruleA]
 173 | 
 174 |     call smartinput#define_rule(b:uruleB)
 175 |     Expect Ref('s:available_nrules') ==# [b:nruleB, b:nruleA]
 176 | 
 177 |     call smartinput#define_rule(b:uruleBd)
 178 |     Expect Ref('s:available_nrules') ==# [b:nruleBd, b:nruleA]
 179 |   end
 180 | 
 181 |   it 'should sort defined rules by priority in descending order (1)'
 182 |     Expect b:nruleA.priority < b:nruleB.priority
 183 | 
 184 |     " Because of the default configuration.
 185 |     Expect Ref('s:available_nrules') !=# []
 186 | 
 187 |     call Set('s:available_nrules', [])
 188 |     Expect Ref('s:available_nrules') ==# []
 189 | 
 190 |     call smartinput#define_rule(b:uruleA)
 191 |     call smartinput#define_rule(b:uruleB)
 192 |     Expect Ref('s:available_nrules') ==# [b:nruleB, b:nruleA]
 193 | 
 194 |   end
 195 | 
 196 |   it 'should sort defined rules by priority in descending order (2)'
 197 |     Expect b:nruleA.priority < b:nruleB.priority
 198 | 
 199 |     " Because of the default configuration.
 200 |     Expect Ref('s:available_nrules') !=# []
 201 | 
 202 |     call Set('s:available_nrules', [])
 203 |     Expect Ref('s:available_nrules') ==# []
 204 | 
 205 |     call smartinput#define_rule(b:uruleB)
 206 |     call smartinput#define_rule(b:uruleA)
 207 |     Expect Ref('s:available_nrules') ==# [b:nruleB, b:nruleA]
 208 |   end
 209 | 
 210 |   it 'should sort defined rules by "priority" and "at" in descending order (1)'
 211 |     Expect b:nruleC1.priority == b:nruleC2.priority
 212 |     Expect b:nruleC1.at <# b:nruleC2.at
 213 | 
 214 |     " Because of the default configuration.
 215 |     Expect Ref('s:available_nrules') !=# []
 216 | 
 217 |     call Set('s:available_nrules', [])
 218 |     Expect Ref('s:available_nrules') ==# []
 219 | 
 220 |     call smartinput#define_rule(b:uruleC1)
 221 |     call smartinput#define_rule(b:uruleC2)
 222 |     Expect Ref('s:available_nrules') ==# [b:nruleC2, b:nruleC1]
 223 |   end
 224 | 
 225 |   it 'should sort defined rules by "priority" and "at" in descending order (2)'
 226 |     Expect b:nruleC1.priority == b:nruleC2.priority
 227 |     Expect b:nruleC1.at <# b:nruleC2.at
 228 | 
 229 |     " Because of the default configuration.
 230 |     Expect Ref('s:available_nrules') !=# []
 231 | 
 232 |     call Set('s:available_nrules', [])
 233 |     Expect Ref('s:available_nrules') ==# []
 234 | 
 235 |     call smartinput#define_rule(b:uruleC2)
 236 |     call smartinput#define_rule(b:uruleC1)
 237 |     Expect Ref('s:available_nrules') ==# [b:nruleC2, b:nruleC1]
 238 |   end
 239 | end
 240 | 
 241 | describe 'smartinput#map_to_trigger'
 242 |   before
 243 |     SaveContext
 244 |     new
 245 | 
 246 |     let M = function('smartinput#map_to_trigger')
 247 | 
 248 |     " With a cursor adjustment.
 249 |     call smartinput#define_rule({
 250 |     \   'at': '\%#',
 251 |     \   'char': '(',
 252 |     \   'input': '()<Left>',
 253 |     \ })
 254 |     call M('i', '<buffer> (', '(', '(')
 255 | 
 256 |     " Without any cursor adjustment.
 257 |     call smartinput#define_rule({
 258 |     \   'at': '\%#',
 259 |     \   'char': '1',
 260 |     \   'input': '123',
 261 |     \ })
 262 |     call M('i', '<buffer> 1', '1', '1')
 263 | 
 264 |     " Failure case - 1.
 265 |     " ... no rule is defined for 'x' for intentional failure.
 266 |     call M('i', '<buffer> F1', 'x', 'x')
 267 | 
 268 |     " Failure case - 2.
 269 |     " ... no rule is defined for 'y' for intentional failure.
 270 |     call M('i', '<buffer> F2', 'x', 'y')
 271 | 
 272 |     " With a special "char".
 273 |     call smartinput#define_rule({
 274 |     \   'at': '(\%#)',
 275 |     \   'char': '<BS>',
 276 |     \   'input': '<BS><Del>',
 277 |     \ })
 278 |     call M('i', '<buffer> <BS>', '<BS>', '<BS>')
 279 | 
 280 |     " With a problematic "char" - ``"''.
 281 |     call smartinput#define_rule({
 282 |     \   'at': '\%#',
 283 |     \   'char': '"',
 284 |     \   'input': '""<Left>',
 285 |     \ })
 286 |     call M('i', '<buffer> "', '"', '"')
 287 | 
 288 |     " With a problematic "char" - ``\''.
 289 |     call smartinput#define_rule({
 290 |     \   'at': '\%#',
 291 |     \   'char': '<Bslash>',
 292 |     \   'input': '<Bslash><Bslash><Left>',
 293 |     \ })
 294 |     call M('i', '<buffer> <Bslash>', '<Bslash>', '<Bslash>')
 295 | 
 296 |     " With automatic indentation.
 297 |     call smartinput#define_rule({
 298 |     \   'at': '{\%#}',
 299 |     \   'char': '<Return>',
 300 |     \   'input': '<Return>*<Return>}<BS><Up><C-o>$<BS>',
 301 |     \ })
 302 |     call M('i', '<buffer> <Return>', '<Return>', '<Return>')
 303 | 
 304 |     " In Command-line mode.
 305 |     call smartinput#define_rule({
 306 |     \   'at': '\[\%#]',
 307 |     \   'char': '<BS>',
 308 |     \   'input': '<BS><Del>',
 309 |     \   'mode': ':',
 310 |     \ })
 311 |     call M('c', '<buffer> <BS>', '<BS>', '<BS>')
 312 |   end
 313 | 
 314 |   after
 315 |     close!
 316 |     ResetContext
 317 |   end
 318 | 
 319 |   it 'should do smart input assistant with cursor adjustment properly'
 320 |     " "let foo =# "
 321 |     call setline(1, 'let foo = ')
 322 |     normal! gg$
 323 |     Expect getline(1, line('$')) ==# ['let foo = ']
 324 |     Expect [line('.'), col('.')] ==# [1, 10]
 325 | 
 326 |     " "let foo = (#)" -- invoke at the end of the line.
 327 |     execute 'normal' "a("
 328 |     Expect getline(1, line('$')) ==# ['let foo = ()']
 329 |     Expect [line('.'), col('.')] ==# [1, 12 - 1]
 330 | 
 331 |     " "let foo = ((#))" -- invoke at a middle of the line.
 332 |     execute 'normal' "a("
 333 |     Expect getline(1, line('$')) ==# ['let foo = (())']
 334 |     Expect [line('.'), col('.')] ==# [1, 13 - 1]
 335 |   end
 336 | 
 337 |   it 'should do smart input assistant without cursor adjustment properly'
 338 |     " "let foo =# "
 339 |     call setline(1, 'let foo = ')
 340 |     normal! gg$
 341 |     Expect getline(1, line('$')) ==# ['let foo = ']
 342 |     Expect [line('.'), col('.')] ==# [1, 10]
 343 | 
 344 |     " "let foo = =>>#" -- invoke at the end of the line.
 345 |     execute 'normal' "a1"
 346 |     Expect getline(1, line('$')) ==# ['let foo = 123']
 347 |     Expect [line('.'), col('.')] ==# [1, 14 - 1]
 348 | 
 349 |     " "let foo = =>=>>#>" -- invoke at a middle of the line.
 350 |     execute 'normal' "i1"
 351 |     Expect getline(1, line('$')) ==# ['let foo = 121233']
 352 |     Expect [line('.'), col('.')] ==# [1, 16 - 1]
 353 |   end
 354 | 
 355 |   it 'should insert a fallback char if there is no proper rule (1)'
 356 |     " "let foo =# "
 357 |     call setline(1, 'let foo = ')
 358 |     normal! gg$
 359 |     Expect getline(1, line('$')) ==# ['let foo = ']
 360 |     Expect [line('.'), col('.')] ==# [1, 10]
 361 | 
 362 |     " "let foo = x#" -- invoke at the end of the line.
 363 |     execute 'normal' "aF1"
 364 |     Expect getline(1, line('$')) ==# ['let foo = x']
 365 |     Expect [line('.'), col('.')] ==# [1, 12 - 1]
 366 | 
 367 |     " "let foox# = x" -- invoke at a middle of the line.
 368 |     execute 'normal' "FoaF1"
 369 |     Expect getline(1, line('$')) ==# ['let foox = x']
 370 |     Expect [line('.'), col('.')] ==# [1, 9 - 1]
 371 |   end
 372 | 
 373 |   it 'should insert a fallback char if there is no proper rule (2)'
 374 |     " "let foo =# "
 375 |     call setline(1, 'let foo = ')
 376 |     normal! gg$
 377 |     Expect getline(1, line('$')) ==# ['let foo = ']
 378 |     Expect [line('.'), col('.')] ==# [1, 10]
 379 | 
 380 |     " "let foo = x#" -- invoke at the end of the line.
 381 |     execute 'normal' "aF2"
 382 |     Expect getline(1, line('$')) ==# ['let foo = y']
 383 |     Expect [line('.'), col('.')] ==# [1, 12 - 1]
 384 | 
 385 |     " "let foox# = x" -- invoke at a middle of the line.
 386 |     execute 'normal' "FoaF2"
 387 |     Expect getline(1, line('$')) ==# ['let fooy = y']
 388 |     Expect [line('.'), col('.')] ==# [1, 9 - 1]
 389 |   end
 390 | 
 391 |   it 'should do smart input assistant with a special "char" properly'
 392 |     " "let foo = (0#)"
 393 |     call setline(1, 'let foo = (0)')
 394 |     normal! gg$
 395 |     Expect getline(1, line('$')) ==# ['let foo = (0)']
 396 |     Expect [line('.'), col('.')] ==# [1, 13]
 397 | 
 398 |     " "let foo = (#)"
 399 |     execute 'normal' "i\<BS>"
 400 |     Expect getline(1, line('$')) ==# ['let foo = ()']
 401 |     Expect [line('.'), col('.')] ==# [1, 12 - 1]
 402 | 
 403 |     " "let foo = #"
 404 |     execute 'normal' "a\<BS>"
 405 |     Expect getline(1, line('$')) ==# ['let foo = ']
 406 |     Expect [line('.'), col('.')] ==# [1, 11 - 1]
 407 |   end
 408 | 
 409 |   it 'should do smart input assistant with a problematic "char" - ``"'''''
 410 |     " 'let foo = [0, #]'
 411 |     call setline(1, 'let foo = [0, ]')
 412 |     normal! gg$
 413 |     Expect getline(1, line('$')) ==# ['let foo = [0, ]']
 414 |     Expect [line('.'), col('.')] ==# [1, 15]
 415 | 
 416 |     " 'let foo = [0, "#"]'
 417 |     execute 'normal' "i\""
 418 |     Expect getline(1, line('$')) ==# ['let foo = [0, ""]']
 419 |     Expect [line('.'), col('.')] ==# [1, 16 - 1]
 420 |   end
 421 | 
 422 |   it 'should do smart input assistant with a problematic "char" - ``\'''''
 423 |     " 'let foo = [0, #]'
 424 |     call setline(1, 'let foo = [0, ]')
 425 |     normal! gg$
 426 |     Expect getline(1, line('$')) ==# ['let foo = [0, ]']
 427 |     Expect [line('.'), col('.')] ==# [1, 15]
 428 | 
 429 |     " 'let foo = [0, \#\]'
 430 |     execute 'normal' "i\\"
 431 |     Expect getline(1, line('$')) ==# ['let foo = [0, \\]']
 432 |     Expect [line('.'), col('.')] ==# [1, 16 - 1]
 433 |   end
 434 | 
 435 |   it 'should keep automatic indentation'
 436 |     setlocal expandtab
 437 |     setlocal smartindent
 438 | 
 439 |     " 'if (foo) {#}'
 440 |     call setline(1, 'if (foo) {}')
 441 |     normal! gg$
 442 |     Expect getline(1, line('$')) ==# ['if (foo) {}']
 443 |     Expect [line('.'), col('.')] ==# [1, 11]
 444 | 
 445 |     " 'if (foo) {'
 446 |     " '        X#'
 447 |     " '}'
 448 |     execute 'normal' "i\<Return>X"
 449 |     Expect getline(1, line('$')) ==# ['if (foo) {',
 450 |     \                                 '        X',
 451 |     \                                 '}']
 452 |     Expect [line('.'), col('.')] ==# [2, 10 - 1]
 453 | 
 454 |     " 'if (foo) {'
 455 |     " '        X'
 456 |     " '        Y#'
 457 |     " '}'
 458 |     execute 'normal' "a\<Return>Y"
 459 |     Expect getline(1, line('$')) ==# ['if (foo) {',
 460 |     \                                 '        X',
 461 |     \                                 '        Y',
 462 |     \                                 '}']
 463 |     Expect [line('.'), col('.')] ==# [3, 10 - 1]
 464 | 
 465 |     " 'if (foo) {'
 466 |     " '        X'
 467 |     " '        Y'
 468 |     " ''
 469 |     " '        Z#'
 470 |     " '}'
 471 |     execute 'normal' "a\<Return>\<Return>Z"
 472 |     Expect getline(1, line('$')) ==# ['if (foo) {',
 473 |     \                                 '        X',
 474 |     \                                 '        Y',
 475 |     \                                 '',
 476 |     \                                 '        Z',
 477 |     \                                 '}']
 478 |     Expect [line('.'), col('.')] ==# [5, 10 - 1]
 479 |   end
 480 | 
 481 |   it 'should do smart input assistant in Command-line mode'
 482 |     let b:.log = []
 483 |     function! b:.check()
 484 |       call add(b:.log, [getcmdtype(), getcmdline(), getcmdpos()])
 485 |       return ''
 486 |     endfunction
 487 |     cnoremap <buffer> <expr> C  b:.check()
 488 | 
 489 |     " '([x#])'
 490 |     " '([#])'
 491 |     " '(#)'
 492 |     " '#)'
 493 |     execute 'normal' ":([x])\<Left>\<Left>C\<BS>C\<BS>C\<BS>C\<C-c>"
 494 |     Expect b:.log ==# [
 495 |     \   [':', '([x])', 4],
 496 |     \   [':', '([])', 3],
 497 |     \   [':', '()', 2],
 498 |     \   [':', ')', 1],
 499 |     \ ]
 500 |   end
 501 | end
 502 | 
 503 | describe 'The default configuration'
 504 |   before
 505 |     new
 506 |     setlocal autoindent
 507 | 
 508 |     function! b:.test_rules(test_set_table)
 509 |       " NB: [WHAT_MAP_EXPR_CAN_SEE] For some reason, ":normal SLet's" doesn't
 510 |       " work as I expected.  When "'" is being inserted with the command,
 511 |       " s:_trigger_or_fallback is called with the following context:
 512 |       "
 513 |       " * getline('.') ==# ''
 514 |       " * [line('.'), col('.')] == [1, 1]
 515 |       "
 516 |       " So that the expected rule ("at" ==# '\w\%#') is NOT selected.
 517 |       "
 518 |       " But when "'" is being inserted with interactively typed "Let's",
 519 |       " s:_trigger_or_fallback is called with the following context:
 520 |       "
 521 |       " * getline('.') ==# 'Let'
 522 |       " * [line('.'), col('.')] == [1, 4]
 523 |       "
 524 |       " So that the expected rule ("at" ==# '\w\%#') is selected.
 525 |       "
 526 |       " To avoid the problem, split :normal at the trigger character.
 527 |       for n in sort(keys(a:test_set_table))
 528 |         let test_set = a:test_set_table[n]
 529 |         % delete _
 530 |         let i = 0  " For debugging.
 531 |         for [input, lines, linenr, colnr] in test_set
 532 |           let i += 1
 533 |           execute 'normal' 'a'.input
 534 |           Expect [n, i, getline(1, line('$'))] ==# [n, i, lines]
 535 |           Expect [n, i, [line('.'), col('.')]] ==# [n, i, [linenr, colnr]]
 536 |         endfor
 537 |       endfor
 538 |     endfunction
 539 |   end
 540 | 
 541 |   after
 542 |     close!
 543 |   end
 544 | 
 545 |   it 'should define necessary key mappings to trigger smart input assistants'
 546 |     redir => s
 547 |     0 verbose imap
 548 |     redir END
 549 |     let lhss = split(s, '\n')
 550 |     call map(lhss, 'substitute(v:val, ''\v\S+\s+(\S+)\s+.*'', ''\1'', ''g'')')
 551 |     call sort(lhss)
 552 | 
 553 |     Expect lhss ==# [
 554 |     \   '"',
 555 |     \   '''',
 556 |     \   '(',
 557 |     \   ')',
 558 |     \   '<BS>',
 559 |     \   '<C-H>',
 560 |     \   '<CR>',
 561 |     \   '<NL>',
 562 |     \   '[',
 563 |     \   ']',
 564 |     \   '`',
 565 |     \   '{',
 566 |     \   '}',
 567 |     \ ]
 568 |   end
 569 | 
 570 |   it 'should have generic rules for all filetypes'
 571 |     call b:.test_rules({
 572 |     \   '"" complete': [
 573 |     \     ["\"", ['""'], 1, 2 - 1],
 574 |     \   ],
 575 |     \   '"" escape #1': [
 576 |     \     ["\\", ['\'], 1, 2 - 1],
 577 |     \     ["\"", ['\"'], 1, 3 - 1],
 578 |     \   ],
 579 |     \   '"" escape #2': [
 580 |     \     ["\"", ['""'], 1, 2 - 1],
 581 |     \     ["\\", ['"\"'], 1, 3 - 1],
 582 |     \     ["\"", ['"\""'], 1, 4 - 1],
 583 |     \     ["\"", ['"\""'], 1, 5 - 1],
 584 |     \   ],
 585 |     \   '"" leave #1': [
 586 |     \     ["\"", ['""'], 1, 2 - 1],
 587 |     \     ["\"", ['""'], 1, 3 - 1],
 588 |     \   ],
 589 |     \   '"" leave #2': [
 590 |     \     ["\"", ['""'], 1, 2 - 1],
 591 |     \     ["x", ['"x"'], 1, 3 - 1],
 592 |     \     ["\"", ['"x"'], 1, 4 - 1],
 593 |     \   ],
 594 |     \   '"" undo #1': [
 595 |     \     ["\"", ['""'], 1, 2 - 1],
 596 |     \     ["x", ['"x"'], 1, 3 - 1],
 597 |     \     ["\<BS>", ['""'], 1, 2 - 1],
 598 |     \     ["\<BS>", [''], 1, 0 + 1],
 599 |     \   ],
 600 |     \   '"" undo #2': [
 601 |     \     ["x", ['x'], 1, 2 - 1],
 602 |     \     ["\"", ['x""'], 1, 3 - 1],
 603 |     \     ["\"", ['x""'], 1, 4 - 1],
 604 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 605 |     \   ],
 606 |     \   '""" complete': [
 607 |     \     ["\"", ['""'], 1, 2 - 1],
 608 |     \     ["\"", ['""'], 1, 3 - 1],
 609 |     \     ["\"", ['""""""'], 1, 4 - 1],
 610 |     \   ],
 611 |     \   '""" leave #1': [
 612 |     \     ["\"", ['""'], 1, 2 - 1],
 613 |     \     ["\"", ['""'], 1, 3 - 1],
 614 |     \     ["\"", ['""""""'], 1, 4 - 1],
 615 |     \     ["\"", ['""""""'], 1, 7 - 1],
 616 |     \   ],
 617 |     \   '""" leave #2': [
 618 |     \     ["\"", ['""'], 1, 2 - 1],
 619 |     \     ["\"", ['""'], 1, 3 - 1],
 620 |     \     ["\"", ['""""""'], 1, 4 - 1],
 621 |     \     ["x", ['"""x"""'], 1, 5 - 1],
 622 |     \     ["\"", ['"""x"""'], 1, 8 - 1],
 623 |     \   ],
 624 |     \   '""" undo #1': [
 625 |     \     ["\"", ['""'], 1, 2 - 1],
 626 |     \     ["\"", ['""'], 1, 3 - 1],
 627 |     \     ["\"", ['""""""'], 1, 4 - 1],
 628 |     \     ["x", ['"""x"""'], 1, 5 - 1],
 629 |     \     ["\<BS>", ['""""""'], 1, 4 - 1],
 630 |     \     ["\<BS>", [''], 1, 0 + 1],
 631 |     \   ],
 632 |     \   '""" undo #2': [
 633 |     \     ["x", ['x'], 1, 2 - 1],
 634 |     \     ["\"", ['x""'], 1, 3 - 1],
 635 |     \     ["\"", ['x""'], 1, 4 - 1],
 636 |     \     ["\"", ['x""""""'], 1, 5 - 1],
 637 |     \     ["\<End>", ['x""""""'], 1, 8 - 1],
 638 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 639 |     \   ],
 640 |     \   '''''': [
 641 |     \     ["'", [''''''], 1, 2 - 1],
 642 |     \     ["'", [''''''], 1, 3 - 1],
 643 |     \     ["\<Left>", [''''''], 1, 2 - 1],
 644 |     \     ["x", ['''x'''], 1, 3 - 1],
 645 |     \     ["'", ['''x'''], 1, 4 - 1],
 646 |     \     ["\<Left>", ['''x'''], 1, 3 - 1],
 647 |     \     ["\<BS>", [''''''], 1, 2 - 1],
 648 |     \     ["\<BS>", [''], 1, 2 - 1],
 649 |     \     ["\\", ['\'], 1, 2 - 1],
 650 |     \     ["'", ['\'''], 1, 3 - 1],
 651 |     \   ],
 652 |     \   ''''' complete': [
 653 |     \     ["'", [''''''], 1, 2 - 1],
 654 |     \   ],
 655 |     \   ''''' escape #1': [
 656 |     \     ["\\", ['\'], 1, 2 - 1],
 657 |     \     ["'", ['\'''], 1, 3 - 1],
 658 |     \   ],
 659 |     \   ''''' escape #2': [
 660 |     \     ["'", [''''''], 1, 2 - 1],
 661 |     \     ["\\", ['''\'''], 1, 3 - 1],
 662 |     \     ["'", ['''\'''''], 1, 4 - 1],
 663 |     \     ["'", ['''\'''''], 1, 5 - 1],
 664 |     \   ],
 665 |     \   ''''' leave #1': [
 666 |     \     ["'", [''''''], 1, 2 - 1],
 667 |     \     ["'", [''''''], 1, 3 - 1],
 668 |     \   ],
 669 |     \   ''''' leave #2': [
 670 |     \     ["'", [''''''], 1, 2 - 1],
 671 |     \     ["x", ['''x'''], 1, 3 - 1],
 672 |     \     ["'", ['''x'''], 1, 4 - 1],
 673 |     \   ],
 674 |     \   ''''' undo #1': [
 675 |     \     ["'", [''''''], 1, 2 - 1],
 676 |     \     ["x", ['''x'''], 1, 3 - 1],
 677 |     \     ["\<BS>", [''''''], 1, 2 - 1],
 678 |     \     ["\<BS>", [''], 1, 0 + 1],
 679 |     \   ],
 680 |     \   ''''' undo #2': [
 681 |     \     ["x", ['x'], 1, 2 - 1],
 682 |     \     ["\<C-v>'", ['x'''], 1, 3 - 1],
 683 |     \     ["\<C-v>'", ['x'''''], 1, 4 - 1],
 684 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 685 |     \   ],
 686 |     \   ''''''' complete': [
 687 |     \     ["'", [''''''], 1, 2 - 1],
 688 |     \     ["'", [''''''], 1, 3 - 1],
 689 |     \     ["'", [''''''''''''''], 1, 4 - 1],
 690 |     \   ],
 691 |     \   ''''''' leave #1': [
 692 |     \     ["'", [''''''], 1, 2 - 1],
 693 |     \     ["'", [''''''], 1, 3 - 1],
 694 |     \     ["'", [''''''''''''''], 1, 4 - 1],
 695 |     \     ["'", [''''''''''''''], 1, 7 - 1],
 696 |     \   ],
 697 |     \   ''''''' leave #2': [
 698 |     \     ["'", [''''''], 1, 2 - 1],
 699 |     \     ["'", [''''''], 1, 3 - 1],
 700 |     \     ["'", [''''''''''''''], 1, 4 - 1],
 701 |     \     ["x", ['''''''x'''''''], 1, 5 - 1],
 702 |     \     ["'", ['''''''x'''''''], 1, 8 - 1],
 703 |     \   ],
 704 |     \   ''''''' undo #1': [
 705 |     \     ["'", [''''''], 1, 2 - 1],
 706 |     \     ["'", [''''''], 1, 3 - 1],
 707 |     \     ["'", [''''''''''''''], 1, 4 - 1],
 708 |     \     ["x", ['''''''x'''''''], 1, 5 - 1],
 709 |     \     ["\<BS>", [''''''''''''''], 1, 4 - 1],
 710 |     \     ["\<BS>", [''], 1, 0 + 1],
 711 |     \   ],
 712 |     \   ''''''' undo #2': [
 713 |     \     ["x", ['x'], 1, 2 - 1],
 714 |     \     ["\<C-v>'", ['x'''], 1, 3 - 1],
 715 |     \     ["\<C-v>'", ['x'''''], 1, 4 - 1],
 716 |     \     ["'", ['x'''''''''''''], 1, 5 - 1],
 717 |     \     ["\<End>", ['x'''''''''''''], 1, 8 - 1],
 718 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 719 |     \   ],
 720 |     \   '() complete': [
 721 |     \     ["(", ['()'], 1, 2 - 1],
 722 |     \   ],
 723 |     \   '() escape': [
 724 |     \     ["\\", ['\'], 1, 2 - 1],
 725 |     \     ["(", ['\('], 1, 3 - 1],
 726 |     \   ],
 727 |     \   '() leave #1': [
 728 |     \     ["(", ['()'], 1, 2 - 1],
 729 |     \     [")", ['()'], 1, 3 - 1],
 730 |     \   ],
 731 |     \   '() leave #2': [
 732 |     \     ["(", ['()'], 1, 2 - 1],
 733 |     \     ["x", ['(x)'], 1, 3 - 1],
 734 |     \     [")", ['(x)'], 1, 4 - 1],
 735 |     \   ],
 736 |     \   '() leave #3': [
 737 |     \     ["(", ['()'], 1, 2 - 1],
 738 |     \     ["  x  \<Left>\<Left>", ['(  x  )'], 1, 5 - 1],
 739 |     \     [")", ['(  x  )'], 1, 8 - 1],
 740 |     \   ],
 741 |     \   '() leave #4': [
 742 |     \     ["(", ['()'], 1, 2 - 1],
 743 |     \     ["\<Enter>x", ['(', 'x', ')'], 2, 2 - 1],
 744 |     \     [")", ['(', 'x', ')'], 3, 2 - 1],
 745 |     \   ],
 746 |     \   '() leave #5': [
 747 |     \     ["(", ['()'], 1, 2 - 1],
 748 |     \     ["\<Enter>", ['(', '', ')'], 2, 0 + 1],
 749 |     \     ["(", ['(', '()', ')'], 2, 2 - 1],
 750 |     \     ["\<Enter>x", ['(', '(', 'x', ')', ')'], 3, 2 - 1],
 751 |     \     [")", ['(', '(', 'x', ')', ')'], 4, 2 - 1],
 752 |     \     [")", ['(', '(', 'x', ')', ')'], 5, 2 - 1],
 753 |     \   ],
 754 |     \   '() undo #1': [
 755 |     \     ["(", ['()'], 1, 2 - 1],
 756 |     \     ["x", ['(x)'], 1, 3 - 1],
 757 |     \     ["\<BS>", ['()'], 1, 2 - 1],
 758 |     \     ["\<BS>", [''], 1, 0 + 1],
 759 |     \   ],
 760 |     \   '() undo #2': [
 761 |     \     ["x", ['x'], 1, 2 - 1],
 762 |     \     ["(", ['x()'], 1, 3 - 1],
 763 |     \     [")", ['x()'], 1, 4 - 1],
 764 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 765 |     \   ],
 766 |     \   'English': [
 767 |     \     ["Let", ['Let'], 1, 4 - 1],
 768 |     \     ["'", ['Let'''], 1, 5 - 1],
 769 |     \     ["s", ['Let''s'], 1, 6 - 1],
 770 |     \     [" ", ['Let''s '], 1, 7 - 1],
 771 |     \     ["'", ['Let''s '''''], 1, 8 - 1],
 772 |     \     ["quote", ['Let''s ''quote'''], 1, 13 - 1],
 773 |     \   ],
 774 |     \   '[] complete': [
 775 |     \     ["[", ['[]'], 1, 2 - 1],
 776 |     \   ],
 777 |     \   '[] escape': [
 778 |     \     ["\\", ['\'], 1, 2 - 1],
 779 |     \     ["[", ['\['], 1, 3 - 1],
 780 |     \   ],
 781 |     \   '[] leave #1': [
 782 |     \     ["[", ['[]'], 1, 2 - 1],
 783 |     \     ["]", ['[]'], 1, 3 - 1],
 784 |     \   ],
 785 |     \   '[] leave #2': [
 786 |     \     ["[", ['[]'], 1, 2 - 1],
 787 |     \     ["x", ['[x]'], 1, 3 - 1],
 788 |     \     ["]", ['[x]'], 1, 4 - 1],
 789 |     \   ],
 790 |     \   '[] leave #3': [
 791 |     \     ["[", ['[]'], 1, 2 - 1],
 792 |     \     ["  x  \<Left>\<Left>", ['[  x  ]'], 1, 5 - 1],
 793 |     \     ["]", ['[  x  ]'], 1, 8 - 1],
 794 |     \   ],
 795 |     \   '[] leave #4': [
 796 |     \     ["[", ['[]'], 1, 2 - 1],
 797 |     \     ["\<Enter>x\<Enter>\<Up>\<Right>", ['[', 'x', ']'], 2, 2 - 1],
 798 |     \     ["]", ['[', 'x', ']'], 3, 2 - 1],
 799 |     \   ],
 800 |     \   '[] leave #5': [
 801 |     \     ["[", ['[]'], 1, 2 - 1],
 802 |     \     ["\<Enter>\<Enter>\<Up>", ['[', '', ']'], 2, 0 + 1],
 803 |     \     ["[", ['[', '[]', ']'], 2, 2 - 1],
 804 |     \     ["\<Enter>\<Enter>\<Up>x", ['[', '[', 'x', ']', ']'], 3, 2 - 1],
 805 |     \     ["]", ['[', '[', 'x', ']', ']'], 4, 2 - 1],
 806 |     \     ["]", ['[', '[', 'x', ']', ']'], 5, 2 - 1],
 807 |     \   ],
 808 |     \   '[] undo #1': [
 809 |     \     ["[", ['[]'], 1, 2 - 1],
 810 |     \     ["x", ['[x]'], 1, 3 - 1],
 811 |     \     ["\<BS>", ['[]'], 1, 2 - 1],
 812 |     \     ["\<BS>", [''], 1, 0 + 1],
 813 |     \   ],
 814 |     \   '[] undo #2': [
 815 |     \     ["x", ['x'], 1, 2 - 1],
 816 |     \     ["[", ['x[]'], 1, 3 - 1],
 817 |     \     ["]", ['x[]'], 1, 4 - 1],
 818 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 819 |     \   ],
 820 |     \   '`` complete': [
 821 |     \     ["`", ['``'], 1, 2 - 1],
 822 |     \   ],
 823 |     \   '`` escape #1': [
 824 |     \     ["\\", ['\'], 1, 2 - 1],
 825 |     \     ["`", ['\`'], 1, 3 - 1],
 826 |     \   ],
 827 |     \   '`` escape #2': [
 828 |     \     ["`", ['``'], 1, 2 - 1],
 829 |     \     ["\\", ['`\`'], 1, 3 - 1],
 830 |     \     ["`", ['`\``'], 1, 4 - 1],
 831 |     \     ["`", ['`\``'], 1, 5 - 1],
 832 |     \   ],
 833 |     \   '`` leave #1': [
 834 |     \     ["`", ['``'], 1, 2 - 1],
 835 |     \     ["`", ['``'], 1, 3 - 1],
 836 |     \   ],
 837 |     \   '`` leave #2': [
 838 |     \     ["`", ['``'], 1, 2 - 1],
 839 |     \     ["x", ['`x`'], 1, 3 - 1],
 840 |     \     ["`", ['`x`'], 1, 4 - 1],
 841 |     \   ],
 842 |     \   '`` undo #1': [
 843 |     \     ["`", ['``'], 1, 2 - 1],
 844 |     \     ["x", ['`x`'], 1, 3 - 1],
 845 |     \     ["\<BS>", ['``'], 1, 2 - 1],
 846 |     \     ["\<BS>", [''], 1, 0 + 1],
 847 |     \   ],
 848 |     \   '`` undo #2': [
 849 |     \     ["x", ['x'], 1, 2 - 1],
 850 |     \     ["`", ['x``'], 1, 3 - 1],
 851 |     \     ["`", ['x``'], 1, 4 - 1],
 852 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 853 |     \   ],
 854 |     \   '``` complete': [
 855 |     \     ["`", ['``'], 1, 2 - 1],
 856 |     \     ["`", ['``'], 1, 3 - 1],
 857 |     \     ["`", ['``````'], 1, 4 - 1],
 858 |     \   ],
 859 |     \   '``` leave #1': [
 860 |     \     ["`", ['``'], 1, 2 - 1],
 861 |     \     ["`", ['``'], 1, 3 - 1],
 862 |     \     ["`", ['``````'], 1, 4 - 1],
 863 |     \     ["`", ['``````'], 1, 7 - 1],
 864 |     \   ],
 865 |     \   '``` leave #2': [
 866 |     \     ["`", ['``'], 1, 2 - 1],
 867 |     \     ["`", ['``'], 1, 3 - 1],
 868 |     \     ["`", ['``````'], 1, 4 - 1],
 869 |     \     ["x", ['```x```'], 1, 5 - 1],
 870 |     \     ["`", ['```x```'], 1, 8 - 1],
 871 |     \   ],
 872 |     \   '``` undo #1': [
 873 |     \     ["`", ['``'], 1, 2 - 1],
 874 |     \     ["`", ['``'], 1, 3 - 1],
 875 |     \     ["`", ['``````'], 1, 4 - 1],
 876 |     \     ["x", ['```x```'], 1, 5 - 1],
 877 |     \     ["\<BS>", ['``````'], 1, 4 - 1],
 878 |     \     ["\<BS>", [''], 1, 0 + 1],
 879 |     \   ],
 880 |     \   '``` undo #2': [
 881 |     \     ["x", ['x'], 1, 2 - 1],
 882 |     \     ["`", ['x``'], 1, 3 - 1],
 883 |     \     ["`", ['x``'], 1, 4 - 1],
 884 |     \     ["`", ['x``````'], 1, 5 - 1],
 885 |     \     ["\<End>", ['x``````'], 1, 8 - 1],
 886 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 887 |     \   ],
 888 |     \   '{} complete': [
 889 |     \     ["{", ['{}'], 1, 2 - 1],
 890 |     \   ],
 891 |     \   '{} escape': [
 892 |     \     ["\\", ['\'], 1, 2 - 1],
 893 |     \     ["{", ['\{'], 1, 3 - 1],
 894 |     \   ],
 895 |     \   '{} leave #1': [
 896 |     \     ["{", ['{}'], 1, 2 - 1],
 897 |     \     ["}", ['{}'], 1, 3 - 1],
 898 |     \   ],
 899 |     \   '{} leave #2': [
 900 |     \     ["{", ['{}'], 1, 2 - 1],
 901 |     \     ["x", ['{x}'], 1, 3 - 1],
 902 |     \     ["}", ['{x}'], 1, 4 - 1],
 903 |     \   ],
 904 |     \   '{} leave #3': [
 905 |     \     ["{", ['{}'], 1, 2 - 1],
 906 |     \     ["  x  \<Left>\<Left>", ['{  x  }'], 1, 5 - 1],
 907 |     \     ["}", ['{  x  }'], 1, 8 - 1],
 908 |     \   ],
 909 |     \   '{} leave #4': [
 910 |     \     ["{", ['{}'], 1, 2 - 1],
 911 |     \     ["\<Enter>  x", ['{', '  x', '}'], 2, 4 - 1],
 912 |     \     ["}", ['{', '  x', '}'], 3, 2 - 1],
 913 |     \   ],
 914 |     \   '{} leave #5': [
 915 |     \     ["{", ['{}'], 1, 2 - 1],
 916 |     \     ["\<Enter>  ", ['{', '  ', '}'], 2, 3 - 1],
 917 |     \     ["{", ['{', '  {}', '}'], 2, 4 - 1],
 918 |     \     ["\<Enter>  x", ['{', '  {', '    x', '  }', '}'], 3, 6 - 1],
 919 |     \     ["}", ['{', '  {', '    x', '  }', '}'], 4, 4 - 1],
 920 |     \     ["}", ['{', '  {', '    x', '  }', '}'], 5, 2 - 1],
 921 |     \   ],
 922 |     \   '{} undo #1': [
 923 |     \     ["{", ['{}'], 1, 2 - 1],
 924 |     \     ["x", ['{x}'], 1, 3 - 1],
 925 |     \     ["\<BS>", ['{}'], 1, 2 - 1],
 926 |     \     ["\<BS>", [''], 1, 0 + 1],
 927 |     \   ],
 928 |     \   '{} undo #2': [
 929 |     \     ["x", ['x'], 1, 2 - 1],
 930 |     \     ["{", ['x{}'], 1, 3 - 1],
 931 |     \     ["}", ['x{}'], 1, 4 - 1],
 932 |     \     ["\<BS>", ['x'], 1, 2 - 1],
 933 |     \   ],
 934 |     \ })
 935 |   end
 936 | 
 937 |   it 'should have rules to write Lisp/Scheme source code'
 938 |     " NB: For some reason, :setfiletype doesn't work as I expected.
 939 | 
 940 |     function! b:.getSynNames(line, col)
 941 |       return map(synstack(a:line, a:col),
 942 |       \          'synIDattr(synIDtrans(v:val), "name")')
 943 |     endfunction
 944 | 
 945 |     setlocal filetype=foo
 946 |     Expect &l:filetype ==# 'foo'
 947 |     normal S(define filetype 'foo
 948 |     Expect getline(1, line('$')) ==# ['(define filetype ''foo'')']
 949 |     Expect [line('.'), col('.')] ==# [1, 22 - 1]
 950 |     Expect b:.getSynNames(line('.'), col('.')) ==# []
 951 |     normal S(define filetype "'foo
 952 |     Expect getline(1, line('$')) ==# ['(define filetype "''foo''")']
 953 |     Expect [line('.'), col('.')] ==# [1, 23 - 1]
 954 |     Expect b:.getSynNames(line('.'), col('.')) ==# []
 955 |     normal S; (define filetype 'foo
 956 |     Expect getline(1, line('$')) ==# ['; (define filetype ''foo'')']
 957 |     Expect [line('.'), col('.')] ==# [1, 24 - 1]
 958 |     Expect b:.getSynNames(line('.'), col('.')) ==# []
 959 | 
 960 |     setlocal filetype=lisp
 961 |     Expect &l:filetype ==# 'lisp'
 962 |     normal S(define filetype 'lisp
 963 |     Expect getline(1, line('$')) ==# ['(define filetype ''lisp)']
 964 |     Expect [line('.'), col('.')] ==# [1, 23 - 1]
 965 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['lispList', 'Identifier']
 966 |     normal S(define filetype "'lisp
 967 |     Expect getline(1, line('$')) ==# ['(define filetype "''lisp''")']
 968 |     Expect [line('.'), col('.')] ==# [1, 24 - 1]
 969 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['lispList', 'Constant']
 970 |     normal S; (define filetype 'lisp
 971 |     Expect getline(1, line('$')) ==# ['; (define filetype ''lisp)']
 972 |     Expect [line('.'), col('.')] ==# [1, 25 - 1]
 973 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['Comment']
 974 | 
 975 |     setlocal filetype=scheme
 976 |     Expect &l:filetype ==# 'scheme'
 977 |     normal S(define filetype 'scheme
 978 |     Expect getline(1, line('$')) ==# ['(define filetype ''scheme)']
 979 |     Expect [line('.'), col('.')] ==# [1, 25 - 1]
 980 |     normal S(define filetype "'scheme
 981 |     Expect getline(1, line('$')) ==# ['(define filetype "''scheme''")']
 982 |     Expect [line('.'), col('.')] ==# [1, 26 - 1]
 983 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['schemeForm', 'Constant']
 984 |     normal S; (define filetype 'scheme
 985 |     Expect getline(1, line('$')) ==# ['; (define filetype ''scheme)']
 986 |     Expect [line('.'), col('.')] ==# [1, 27 - 1]
 987 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['Comment']
 988 | 
 989 |     setlocal filetype=clojure
 990 |     setlocal syntax=lisp
 991 |     Expect &l:filetype ==# 'clojure'
 992 |     Expect &l:syntax ==# 'lisp'
 993 |     normal S(def filetype 'clojure
 994 |     Expect getline(1, line('$')) ==# ['(def filetype ''clojure)']
 995 |     Expect [line('.'), col('.')] ==# [1, 23 - 1]
 996 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['lispList', 'Identifier']
 997 |     normal S(def filetype "'clojure
 998 |     Expect getline(1, line('$')) ==# ['(def filetype "''clojure''")']
 999 |     Expect [line('.'), col('.')] ==# [1, 24 - 1]
1000 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['lispList', 'Constant']
1001 |     normal S; (def filetype 'clojure
1002 |     Expect getline(1, line('$')) ==# ['; (def filetype ''clojure)']
1003 |     Expect [line('.'), col('.')] ==# [1, 25 - 1]
1004 |     Expect b:.getSynNames(line('.'), col('.')) ==# ['Comment']
1005 |   end
1006 | 
1007 |   it 'should have rules to expand a () block and a {} block'
1008 |     setfiletype ruby
1009 |     setlocal expandtab shiftwidth=2 softtabstop=2
1010 | 
1011 |     let keys = ["\<Enter>", "\<Return>", "\<CR>", "\<C-m>", "\<NL>", "\<C-j>"]
1012 |     for additional_indentkeys in ['', '*<Return>']
1013 |       " Some configurations for automatic indentation perform indentation
1014 |       " before breaking the current line, while the others do not so.  For
1015 |       " example, $VIMRUNTIME/indent/php.vim performs such indentation.  So
1016 |       " that we have to test both cases.
1017 |       setlocal indentkeys<
1018 |       let &l:indentkeys .= ',' . additional_indentkeys
1019 | 
1020 |       for key in keys
1021 |         let note = [strtrans(key), additional_indentkeys]
1022 | 
1023 |         % delete _
1024 |         execute 'normal' printf('ifoo(%sbar,%sbaz', key, key)
1025 |         Expect [note, line('.'), col('.'), getline(1, line('$'))]
1026 |         \ ==# [
1027 |         \   note,
1028 |         \   3, 6 - 1,
1029 |         \   [
1030 |         \     'foo(',
1031 |         \     '  bar,',
1032 |         \     '  baz',
1033 |         \     ')',
1034 |         \   ],
1035 |         \ ]
1036 | 
1037 |         % delete _
1038 |         execute 'normal' printf('i{%sfoo()%sbar()', key, key)
1039 |         Expect [note, line('.'), col('.'), getline(1, line('$'))]
1040 |         \ ==# [
1041 |         \   note,
1042 |         \   3, 8 - 1,
1043 |         \   [
1044 |         \     '{',
1045 |         \     '  foo()',
1046 |         \     '  bar()',
1047 |         \     '}',
1048 |         \   ],
1049 |         \ ]
1050 |       endfor
1051 |     endfor
1052 |   end
1053 | 
1054 |   it 'should have rules to input comments and strings easily in Vim script'
1055 |     setfiletype vim
1056 | 
1057 |     " `"` at the beginning of a line must be a comment sign.
1058 |     % delete _
1059 |     execute 'normal' 'i" This is a comment.'
1060 |     Expect getline(1, line('$')) ==# ['" This is a comment.']
1061 |     Expect [line('.'), col('.')] ==# [1, 21 - 1]
1062 | 
1063 |     " The comment sign may be indented.
1064 |     % delete _
1065 |     execute 'normal' 'i  " This is an indented comment.'
1066 |     Expect getline(1, line('$')) ==# ['  " This is an indented comment.']
1067 |     Expect [line('.'), col('.')] ==# [1, 33 - 1]
1068 | 
1069 |     " In a comment, `"` is usually inserted as a string literal or an ordinary
1070 |     " English word.  So that it should be completed.
1071 |     % delete _
1072 |     execute 'normal' 'i" This is a '
1073 |     execute 'normal' 'a"'
1074 |     execute 'normal' 'acomment'
1075 |     Expect getline(1, line('$')) ==# ['" This is a "comment"']
1076 |     Expect [line('.'), col('.')] ==# [1, 21 - 1]
1077 | 
1078 |     " `"` after an operator is usually a string literal.
1079 |     % delete _
1080 |     execute 'normal' 'ilet foo = bar . "baz'
1081 |     Expect getline(1, line('$')) ==# ['let foo = bar . "baz"']
1082 |     Expect [line('.'), col('.')] ==# [1, 21 - 1]
1083 | 
1084 |     " But it's hard to guess all cases.  We assume only `"` at the beginning
1085 |     " of a line is a comment sign.  In other words, `"` after non-indent
1086 |     " character is always treated as a string literal.
1087 |     % delete _
1088 |     execute 'normal' 'ilet foo = bar " baz'
1089 |     Expect getline(1, line('$')) ==# ['let foo = bar " baz"']
1090 |     Expect [line('.'), col('.')] ==# [1, 20 - 1]
1091 |   end
1092 | 
1093 |   it 'should have rules for "strong quote" in specific languages'
1094 |     for [is_strong, filetype] in [
1095 |     \   [0, 'c'],
1096 |     \   [0, 'cpp'],
1097 |     \   [0, 'cs'],
1098 |     \   [0, 'javascript'],
1099 |     \   [0, 'python'],
1100 |     \   [1, 'csh'],
1101 |     \   [1, 'perl'],
1102 |     \   [1, 'ruby'],
1103 |     \   [1, 'sh'],
1104 |     \   [1, 'tcsh'],
1105 |     \   [1, 'vim'],
1106 |     \   [1, 'zsh'],
1107 |     \ ]
1108 |       let &l:filetype = filetype
1109 |       % delete _
1110 |       let test_cases = [
1111 |       \   ["'", [[''''''], [1, 2 - 1]], [[''''''], [1, 2 - 1]]],
1112 |       \   ["\\", [['''\'''], [1, 3 - 1]], [['''\'''], [1, 3 - 1]]],
1113 |       \   ["'", [['''\'''''], [1, 4 - 1]], [['''\'''], [1, 4 - 1]]],
1114 |       \   ["'", [['''\'''''], [1, 5 - 1]], [['''\'''''''], [1, 5 - 1]]],
1115 |       \ ]
1116 |       for i in range(len(test_cases))
1117 |         let [input, expected_weak, expected_strong] = test_cases[i]
1118 |         let expected = is_strong ? expected_strong : expected_weak
1119 |         execute 'normal' 'a'.input
1120 |         Expect [&l:filetype, i, [getline(1, line('$')), [line('.'), col('.')]]]
1121 |         \ ==# [filetype, i, expected]
1122 |       endfor
1123 |     endfor
1124 |   end
1125 | 
1126 |   it 'should have rules for Python-specific string literals'
1127 |     setfiletype python
1128 | 
1129 |     let test_set_table = {}
1130 |     for prefix in ['r', 'R',
1131 |     \              'b', 'B', 'br', 'bR', 'Br', 'BR',
1132 |     \              'u', 'U', 'ur', 'uR', 'Ur', 'UR']
1133 |       let test_set_table[printf('%s''...'' in code', prefix)] = [
1134 |       \   [prefix . "", [prefix . ''], 1, len(prefix) + 1 - 1],
1135 |       \   ["'", [prefix . ''''''], 1, len(prefix) + 2 - 1],
1136 |       \   ["x", [prefix . '''x'''], 1, len(prefix) + 3 - 1],
1137 |       \ ]
1138 |       let test_set_table[printf('%s''...'' in string', prefix)] = [
1139 |       \   ["\"", ['""'], 1, 1 + 1 - 1],
1140 |       \   [prefix . "", ['"' . prefix . '"'], 1, 1 + len(prefix) + 1 - 1],
1141 |       \   ["'", ['"' . prefix . '''"'], 1, 1 + len(prefix) + 1 + 1 - 1],
1142 |       \   ["x", ['"' . prefix . '''x"'], 1, 1 + len(prefix) + 2 + 1 - 1],
1143 |       \ ]
1144 |       let test_set_table[printf('%s''...'' in comment (middle)', prefix)] = [
1145 |       \   ["# $\<Left>", ['# $'], 1, 2 + 1 - 1],
1146 |       \   [prefix . "", ['# ' . prefix . '$'], 1, 2 + len(prefix) + 1 - 1],
1147 |       \   ["'", ['# ' . prefix . '''$'], 1, 2 + len(prefix) + 1 + 1 - 1],
1148 |       \   ["x", ['# ' . prefix . '''x$'], 1, 2 + len(prefix) + 2 + 1 - 1],
1149 |       \ ]
1150 |       let test_set_table[printf('%s''...'' in comment (EOL)', prefix)] = [
1151 |       \   ["foo # ", ['foo # '], 1, 6 + 1 - 1],
1152 |       \   [prefix . "", ['foo # ' . prefix . ''], 1, 6 + len(prefix) + 1 - 1],
1153 |       \   ["'", ['foo # ' . prefix . ''''], 1, 6 + len(prefix) + 1 + 1 - 1],
1154 |       \   ["x", ['foo # ' . prefix . '''x'], 1, 6 + len(prefix) + 2 + 1 - 1],
1155 |       \ ]
1156 |     endfor
1157 |     let test_set_table['Typical comment'] = [
1158 |     \   ["# You", ['# You'], 1, 6 - 1],
1159 |     \   ["'", ['# You'''], 1, 7 - 1],
1160 |     \   ["re", ['# You''re'], 1, 9 - 1],
1161 |     \ ]
1162 | 
1163 |     call b:.test_rules(test_set_table)
1164 |   end
1165 | 
1166 |   it 'should be cooperative with Visual-block Insert'
1167 |     for input in ['(foo)bar:', '[foo]bar', '{foo}bar:']
1168 |       % delete _
1169 |       put =['a', 'b', 'c', 'd']
1170 |       1 delete _
1171 |       execute 'normal' "gg0\<C-v>GI".input."\<Esc>"
1172 |       Expect getline(1, '$') ==# [
1173 |       \   input . 'a',
1174 |       \   input . 'b',
1175 |       \   input . 'c',
1176 |       \   input . 'd',
1177 |       \ ]
1178 |       Expect [line('.'), col('.')] ==# [1, 0 + 1]
1179 |     endfor
1180 |   end
1181 | 
1182 |   it 'should be escaped immediately after expanding a block'
1183 |     " Insert mode will never be nested if keys are typed interactively.  But
1184 |     " some key sequences (such as i<C-o>S) typed via :normal or :map cause
1185 |     " "nested" Insert mode, so that <Esc> must be typed twice to return to
1186 |     " Normal mode.  We have to avoid using such key sequences at the moment.
1187 |     " See also: http://groups.google.com/group/vim_dev/browse_thread/thread/a1948a72bb919900
1188 | 
1189 |     % delete _
1190 |     execute 'normal' "ifoo\<Esc>I{\<Return>\<Esc>/o\<Return>"
1191 |     Expect getline(1, '$') ==# [
1192 |     \   '{',
1193 |     \   '',
1194 |     \   '}foo',
1195 |     \ ]
1196 |     " or ['{', '/o', '', '}foo'] if Insert mode is nested.
1197 |     Expect [line('.'), col('.')] ==# [3, 3]
1198 | 
1199 |     % delete _
1200 |     execute 'normal' "ifoo\<Esc>I(\<Return>\<Esc>/o\<Return>"
1201 |     Expect getline(1, '$') ==# [
1202 |     \   '(',
1203 |     \   '',
1204 |     \   ')foo',
1205 |     \ ]
1206 |     " or ['(', '/o', '', ')foo'] if Insert mode is nested.
1207 |     Expect [line('.'), col('.')] ==# [3, 3]
1208 |   end
1209 | 
1210 |   it 'should keep register contents'
1211 |     % delete _
1212 |     let @" = 'foo'
1213 |     execute 'normal' "i{\<Return>"
1214 |     Expect getline(1, '$') ==# [
1215 |     \   '{',
1216 |     \   '',
1217 |     \   '}',
1218 |     \ ]
1219 |     Expect [line('.'), col('.')] ==# [2, 0 + 1]
1220 |     Expect @" ==# 'foo'
1221 |     Expect @0 ==# 'foo'
1222 | 
1223 |     % delete _
1224 |     let @" = 'foo'
1225 |     execute 'normal' "i(\<Return>"
1226 |     Expect getline(1, '$') ==# [
1227 |     \   '(',
1228 |     \   '',
1229 |     \   ')',
1230 |     \ ]
1231 |     Expect [line('.'), col('.')] ==# [2, 0 + 1]
1232 |     Expect @" ==# 'foo'
1233 |     Expect @0 ==# 'foo'
1234 |   end
1235 | end
1236 | 


--------------------------------------------------------------------------------
/t/beep-on-empty-line.t:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | example_count=0
 4 | 
 5 | example_count=$((example_count + 1))
 6 | subject='smartinput#map_to_trigger'
 7 | example='should not beep if the cursor will be moved to an empty line'
 8 | if bundle exec vim-flavor test "${0%.t}.vim" | grep --quiet --invert-match $'\a'
 9 | then
10 |   result='ok'
11 | else
12 |   result='not ok'
13 | fi
14 | echo "$result $example_count - $subject $example"
15 | 
16 | echo "1..$example_count"
17 | 
18 | # vim: filetype=sh
19 | 


--------------------------------------------------------------------------------
/t/beep-on-empty-line.vim:
--------------------------------------------------------------------------------
 1 | runtime! plugin/smartinput.vim
 2 | 
 3 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
 4 | set backspace=indent,eol,start
 5 | 
 6 | describe 'smartinput#map_to_trigger'
 7 |   before
 8 |     SaveContext
 9 |     new
10 | 
11 |     " If the cursor will be moved to an empty line...
12 |     call smartinput#define_rule({
13 |     \   'at': '(\%#)',
14 |     \   'char': '<Return>',
15 |     \   'input': '<Return>X<Return>)<BS><Up><C-o>$<BS>',
16 |     \ })
17 |     call smartinput#map_to_trigger('i', '<buffer> <Return>', '<Return>', '<Return>')
18 |   end
19 | 
20 |   after
21 |     close!
22 |     ResetContext
23 |   end
24 | 
25 |   it 'should not beep if the cursor will be moved to an empty line'
26 |     " 'let foo = (#)'
27 |     call setline(1, 'let foo = ()')
28 |     normal! gg$
29 |     Expect getline(1, line('$')) ==# ['let foo = ()']
30 |     Expect [line('.'), col('.')] ==# [1, 12]
31 | 
32 |     " 'let foo = ('
33 |     " '#'
34 |     " ')'
35 |     execute 'normal' "i\<Return>"
36 |     Expect getline(1, line('$')) ==# ['let foo = (',
37 |     \                                 '',
38 |     \                                 ')']
39 |     Expect [line('.'), col('.')] ==# [2, 1]
40 |   end
41 | end
42 | 


--------------------------------------------------------------------------------
/t/break-undo.vim:
--------------------------------------------------------------------------------
  1 | " NB: MacVim defines several key mappings such as <D-v> by default.
  2 | " The key mappings are defined from the core, not from any runtime file.
  3 | " So that the key mappings are always defined even if Vim is invoked by
  4 | " "vim -u NONE" etc.  Remove the kay mappings to ensure that there is no key
  5 | " mappings, because some tests in this file assume such state.
  6 | imapclear
  7 | cmapclear
  8 | 
  9 | runtime! plugin/smartinput.vim
 10 | 
 11 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
 12 | set backspace=indent,eol,start
 13 | filetype plugin indent on
 14 | syntax enable
 15 | 
 16 | describe 'g:smartinput_break_undo'
 17 |   before
 18 |     call smartinput#clear_rules()
 19 |     new
 20 | 
 21 |     function! b:.test_keys_undo(name, pre_input, table)
 22 |       let n = a:name
 23 |       for i in range(len(a:table))
 24 |         let [input, expects] = a:table[i]
 25 |         normal! gg0D
 26 |         call feedkeys('a' . a:pre_input, 'tx')
 27 |         call feedkeys(input, 'tx')
 28 |         for j in range(len(expects))
 29 |           let expected = expects[j]
 30 |           Expect [n, i, j, getline(1, line('$'))] ==# [n, i, j, [expected]]
 31 |           normal! u
 32 |         endfor
 33 |       endfor
 34 |     endfunction
 35 | 
 36 |     function! b:.test_no_break_undo()
 37 |       " define with "i_CTRL-G_U"
 38 |       call smartinput#define_default_rules()
 39 | 
 40 |       call b:.test_keys_undo('*', 'call ', [
 41 |       \  ['a(foo)bar', ['call (foo)bar', 'call ']],
 42 |       \ ])
 43 | 
 44 |       call b:.test_keys_undo('*', 'echo ', [
 45 |       \  ['a(foo)bar', ['echo (foo)bar', 'echo ']],
 46 |       \  ['a[foo]bar', ['echo [foo]bar', 'echo ']],
 47 |       \  ['a{foo}bar', ['echo {foo}bar', 'echo ']],
 48 |       \  ["a'foo' bar", ["echo 'foo' bar", "echo "]],
 49 |       \  ['a"foo" bar', ['echo "foo" bar', 'echo ']],
 50 |       \  ['a`foo` bar', ['echo `foo` bar', 'echo ']],
 51 |       \  ["a'''foo' bar", ["echo '''foo''' bar", 'echo ']],
 52 |       \  ['a"""foo" bar', ['echo """foo""" bar', 'echo ']],
 53 |       \  ['a```foo` bar', ['echo ```foo``` bar', 'echo ']],
 54 |       \ ])
 55 | 
 56 |       setfiletype python
 57 |       call b:.test_keys_undo('Python string', 'echo ', [
 58 |       \  ["au'foo' bar", ["echo u'foo' bar", "echo "]],
 59 |       \ ])
 60 | 
 61 |       setfiletype lisp
 62 |       call b:.test_keys_undo('Lisp quote', '(define ', [
 63 |       \  ['afiletype "''lisp', ['(define filetype "''lisp''")', '(define )']],
 64 |       \ ])
 65 | 
 66 |       setfiletype vim
 67 |       call b:.test_keys_undo('strong quote', 'echo ', [
 68 |       \  ["a'foo\\' bar", ["echo 'foo\\' bar", "echo "]],
 69 |       \ ])
 70 |     endfunction
 71 |   end
 72 | 
 73 |   after
 74 |     close!
 75 |   end
 76 | 
 77 |   it 'should define the default rules with no-break-undo, if it is not exists'
 78 |     unlet! g:smartinput_break_undo
 79 |     call b:.test_no_break_undo()
 80 |   end
 81 | 
 82 |   it 'should define the default rules with no-break-undo, if it is 0'
 83 |     let g:smartinput_break_undo = 0
 84 |     call b:.test_no_break_undo()
 85 |   end
 86 | 
 87 |   it 'should define the default rules with break-undo, if it is not 0'
 88 |     let g:smartinput_break_undo = !0
 89 | 
 90 |     " define without i_CTRL-G_U
 91 |     call smartinput#define_default_rules()
 92 | 
 93 |     call b:.test_keys_undo('*', 'echo ', [
 94 |     \  ['a(foo)bar', ['echo (foo)bar', 'echo (foo)', 'echo ()', 'echo ']],
 95 |     \  ['a[foo]bar', ['echo [foo]bar', 'echo [foo]', 'echo []', 'echo ']],
 96 |     \  ['a{foo}bar', ['echo {foo}bar', 'echo {foo}', 'echo {}', 'echo ']],
 97 |     \  ["a'foo' bar", ["echo 'foo' bar", "echo 'foo'", "echo ''", 'echo ']],
 98 |     \  ['a"foo" bar', ['echo "foo" bar', 'echo "foo"', 'echo ""', 'echo ']],
 99 |     \  ['a`foo` bar', ['echo `foo` bar', 'echo `foo`', 'echo ``', 'echo ']],
100 |     \  ["a'''foo' bar", ["echo '''foo''' bar", "echo '''foo'''", "echo ''''''", "echo ''", 'echo ']],
101 |     \  ['a"""foo" bar', ['echo """foo""" bar', 'echo """foo"""', 'echo """"""', 'echo ""', 'echo ']],
102 |     \  ['a```foo` bar', ['echo ```foo``` bar', 'echo ```foo```', 'echo ``````', 'echo ``', 'echo ']],
103 |     \ ])
104 | 
105 |     setfiletype python
106 |     call b:.test_keys_undo('Python string', 'echo ', [
107 |     \  ["au'foo' bar", ["echo u'foo' bar", "echo u'foo'", "echo u''", 'echo ']],
108 |     \ ])
109 | 
110 |     setfiletype lisp
111 |     call b:.test_keys_undo('Lisp quote', '(define ', [
112 |     \  ['afiletype "''lisp', ['(define filetype "''lisp''")', '(define filetype "''''")', '(define filetype "")', '(define )']],
113 |     \ ])
114 | 
115 |     setfiletype vim
116 |     call b:.test_keys_undo('strong quote', 'echo ', [
117 |     \  ["a'foo\\' bar", ["echo 'foo\\' bar", "echo 'foo\\'", "echo ''", 'echo ']],
118 |     \ ])
119 |   end
120 | end
121 | 


--------------------------------------------------------------------------------
/t/map_trigger_keys.vim:
--------------------------------------------------------------------------------
  1 | let g:smartinput_no_default_key_mappings = !0
  2 | 
  3 | runtime! plugin/smartinput.vim
  4 | 
  5 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
  6 | 
  7 | describe 'smartinput#map_trigger_keys'
  8 |   before
  9 |     new
 10 | 
 11 |     function! b:.get_lhss(map_command)
 12 |       redir => s
 13 |       execute '0 verbose' a:map_command
 14 |       redir END
 15 |       let lhss = split(s, '\n')
 16 |       call map(lhss, 'substitute(v:val, ''\v\S+\s+(\S+)\s+.*'', ''\1'', "g")')
 17 |       call sort(lhss)
 18 |       return lhss
 19 |     endfunction
 20 | 
 21 |     imapclear
 22 |     cmapclear
 23 |     call smartinput#clear_rules()
 24 |   end
 25 | 
 26 |   after
 27 |     close!
 28 |   end
 29 | 
 30 |   it 'should not map anything but "alias" ones if there is no rule'
 31 |     call smartinput#map_trigger_keys()
 32 | 
 33 |     Expect b:.get_lhss('imap') ==# [
 34 |     \   '<C-H>',
 35 |     \   '<CR>',
 36 |     \   '<NL>',
 37 |     \ ]
 38 |     Expect b:.get_lhss('cmap') ==# [
 39 |     \   '<C-H>',
 40 |     \   '<CR>',
 41 |     \   '<NL>',
 42 |     \ ]
 43 |   end
 44 | 
 45 |   it 'should not override existing key mappings if overridep is omitted'
 46 |     inoremap x  FOO
 47 |     call smartinput#define_rule({'at': '', 'char': 'x', 'input': 'BAR',
 48 |     \                          'mode': 'i'})
 49 |     cnoremap y  foo
 50 |     call smartinput#define_rule({'at': '', 'char': 'y', 'input': 'bar',
 51 |     \                          'mode': ':'})
 52 |     call smartinput#map_trigger_keys()
 53 | 
 54 |     Expect b:.get_lhss('imap') ==# [
 55 |     \   '<C-H>',
 56 |     \   '<CR>',
 57 |     \   '<NL>',
 58 |     \   'x',
 59 |     \ ]
 60 |     Expect maparg('x', 'i') ==# 'FOO'
 61 |     Expect b:.get_lhss('cmap') ==# [
 62 |     \   '<C-H>',
 63 |     \   '<CR>',
 64 |     \   '<NL>',
 65 |     \   'y',
 66 |     \ ]
 67 |     Expect maparg('y', 'c') ==# 'foo'
 68 |   end
 69 | 
 70 |   it 'should not override existing key mappings if overridep is false'
 71 |     inoremap x  FOO
 72 |     call smartinput#define_rule({'at': '', 'char': 'x', 'input': 'BAR',
 73 |     \                          'mode': 'i'})
 74 |     cnoremap y  foo
 75 |     call smartinput#define_rule({'at': '', 'char': 'y', 'input': 'bar',
 76 |     \                          'mode': ':'})
 77 |     call smartinput#map_trigger_keys(!!0)
 78 | 
 79 |     Expect b:.get_lhss('imap') ==# [
 80 |     \   '<C-H>',
 81 |     \   '<CR>',
 82 |     \   '<NL>',
 83 |     \   'x',
 84 |     \ ]
 85 |     Expect maparg('x', 'i') ==# 'FOO'
 86 |     Expect b:.get_lhss('cmap') ==# [
 87 |     \   '<C-H>',
 88 |     \   '<CR>',
 89 |     \   '<NL>',
 90 |     \   'y',
 91 |     \ ]
 92 |     Expect maparg('y', 'c') ==# 'foo'
 93 |   end
 94 | 
 95 |   it 'should override existing key mappings if overridep is true'
 96 |     inoremap x  FOO
 97 |     call smartinput#define_rule({'at': '', 'char': 'x', 'input': 'BAR',
 98 |     \                          'mode': 'i'})
 99 |     cnoremap y  foo
100 |     call smartinput#define_rule({'at': '', 'char': 'y', 'input': 'bar',
101 |     \                          'mode': ':'})
102 |     call smartinput#map_trigger_keys(!0)
103 | 
104 |     Expect b:.get_lhss('imap') ==# [
105 |     \   '<C-H>',
106 |     \   '<CR>',
107 |     \   '<NL>',
108 |     \   'x',
109 |     \ ]
110 |     Expect maparg('x', 'i') !=# 'FOO'
111 |     Expect b:.get_lhss('cmap') ==# [
112 |     \   '<C-H>',
113 |     \   '<CR>',
114 |     \   '<NL>',
115 |     \   'y',
116 |     \ ]
117 |     Expect maparg('y', 'c') !=# 'foo'
118 |   end
119 | end
120 | 


--------------------------------------------------------------------------------
/t/misc.vim:
--------------------------------------------------------------------------------
  1 | runtime! plugin/smartinput.vim
  2 | 
  3 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
  4 | syntax enable
  5 | set backspace=indent,eol,start
  6 | 
  7 | describe 's:calculate_rule_priority'
  8 |   it 'should use "at", "mode", "filetype" and "syntax"'
  9 |     let snrule1 = {
 10 |     \   'at': '\%#',
 11 |     \   'char': '(',
 12 |     \   'input': '()<Left>',
 13 |     \   'mode': 'i',
 14 |     \   'filetype': ['foo', 'bar', 'baz'],
 15 |     \   'syntax': ['String', 'Comment'],
 16 |     \ }
 17 |     Expect Call('s:calculate_rule_priority', snrule1)
 18 |     \      == 3 + 100 / 3 + 100 / 2 + 100 / 1
 19 | 
 20 |     let snrule2 = {
 21 |     \   'at': '\%#',
 22 |     \   'char': '[',
 23 |     \   'input': '[  ]<Left><Left>',
 24 |     \   'mode': 'i',
 25 |     \   'filetype': ['foo', 'bar', 'baz'],
 26 |     \   'syntax': ['String', 'Comment'],
 27 |     \ }
 28 |     Expect Call('s:calculate_rule_priority', snrule2)
 29 |     \      == 3 + 100 / 3 + 100 / 2 + 100 / 1
 30 | 
 31 |     let snrule3 = {
 32 |     \   'at': '\%#',
 33 |     \   'char': '(',
 34 |     \   'input': '<Bslash>(',
 35 |     \   'mode': '/?',
 36 |     \   'filetype': 0,
 37 |     \   'syntax': 0,
 38 |     \ }
 39 |     Expect Call('s:calculate_rule_priority', snrule3)
 40 |     \      == 3 + 0 + 0 + 100 / 2
 41 |   end
 42 | 
 43 |   it 'should use a low value for omitted "filetype" and "syntax"'
 44 |     let snrule = {
 45 |     \   'at': '\%#',
 46 |     \   'char': '(',
 47 |     \   'input': '()<Left>',
 48 |     \   'mode': 'i',
 49 |     \   'filetype': 0,
 50 |     \   'syntax': 0,
 51 |     \ }
 52 |     Expect Call('s:calculate_rule_priority', snrule)
 53 |     \      == 3 + 0 + 0 + 100 / 1
 54 |   end
 55 | end
 56 | 
 57 | describe 's:decode_key_notation'
 58 |   it 'should decode a <Key> notation into an actual byte sequence'
 59 |     Expect Call('s:decode_key_notation', 'foo') ==# "foo"
 60 |     Expect Call('s:decode_key_notation', '"') ==# "\""
 61 |     Expect Call('s:decode_key_notation', '\') ==# "\\"
 62 |     Expect Call('s:decode_key_notation', '<C-h>') ==# "\<C-h>"
 63 |     Expect Call('s:decode_key_notation', '<BS>') ==# "\<BS>"
 64 |     Expect Call('s:decode_key_notation', '<LT><LT>') ==# "\<LT>\<LT>"
 65 |   end
 66 | end
 67 | 
 68 | describe 's:find_the_most_proper_rule_in_command_line_mode'
 69 |   before
 70 |     new
 71 |     let b:nrule1 = Call('s:normalize_rule', {
 72 |     \   'at': '\%#',
 73 |     \   'char': '<LT>',
 74 |     \   'input': '<LT>><Left>',
 75 |     \   'mode': ':',
 76 |     \ })
 77 |     let b:nrule2 = Call('s:normalize_rule', {
 78 |     \   'at': '\w\%#',
 79 |     \   'char': '<LT>',
 80 |     \   'input': '<LT>',
 81 |     \   'mode': ':',
 82 |     \ })
 83 |     let b:nrule3 = Call('s:normalize_rule', {
 84 |     \   'at': '\%#',
 85 |     \   'char': '<LT>',
 86 |     \   'input': '<LT>',
 87 |     \   'filetype': ['lisp', 'scheme'],
 88 |     \   'mode': '/',
 89 |     \ })
 90 |     let b:nrule4 = Call('s:normalize_rule', {
 91 |     \   'at': '\%#',
 92 |     \   'char': '<LT>',
 93 |     \   'input': '<LT>><Left>',
 94 |     \   'filetype': ['lisp', 'scheme'],
 95 |     \   'syntax': ['Comment', 'String'],
 96 |     \   'mode': '/',
 97 |     \ })
 98 |     let b:nrule5 = Call('s:normalize_rule', {
 99 |     \   'at': '\%#',
100 |     \   'char': '<LT>',
101 |     \   'input': 'This rule MUST NOT be selected.',
102 |     \   'mode': 'i',
103 |     \ })
104 |     let b:nrules = [b:nrule5, b:nrule4, b:nrule3, b:nrule2, b:nrule1]
105 | 
106 |     function! b:.find(...)
107 |       return call('Call',
108 |       \           ['s:find_the_most_proper_rule_in_command_line_mode'] + a:000)
109 |     endfunction
110 |   end
111 | 
112 |   after
113 |     close!
114 |   end
115 | 
116 |   it 'should fail if there is no rule for a given char'
117 |     Expect b:.find(b:nrules, '[', '', 1, ':') ==# 0
118 |   end
119 | 
120 |   it 'should fail if there is no rule for a given command-line type'
121 |     Expect b:.find(b:nrules, '<', '', 1, 'X') ==# 0
122 |   end
123 | 
124 |   it 'should check the text under the cursor by "at"'
125 |     " foo #bar
126 |     Expect b:.find(b:nrules, '<', 'foo bar', 5, ':') ==# b:nrule1
127 | 
128 |     " foo# bar
129 |     Expect b:.find(b:nrules, '<', 'foo bar', 4, ':') ==# b:nrule2
130 |   end
131 | 
132 |   it 'should ignore "filetype" and "syntax"'
133 |     setfiletype scheme
134 | 
135 |     " foo #bar
136 |     Expect b:.find(b:nrules, '<', 'foo bar', 5, '/') ==# b:nrule4
137 |   end
138 | end
139 | 
140 | describe 's:find_the_most_proper_rule_in_insert_mode'
141 |   before
142 |     new
143 |     let b:nrule1 = Call('s:normalize_rule', {
144 |     \   'at': '\%#',
145 |     \   'char': '<LT>',
146 |     \   'input': '<LT>><Left>',
147 |     \ })
148 |     let b:nrule2 = Call('s:normalize_rule', {
149 |     \   'at': '\w\%#',
150 |     \   'char': '<LT>',
151 |     \   'input': '<LT>',
152 |     \ })
153 |     let b:nrule3 = Call('s:normalize_rule', {
154 |     \   'at': '\%#',
155 |     \   'char': '<LT>',
156 |     \   'input': '<LT>',
157 |     \   'filetype': ['lisp', 'scheme'],
158 |     \ })
159 |     let b:nrule4 = Call('s:normalize_rule', {
160 |     \   'at': '\%#',
161 |     \   'char': '<LT>',
162 |     \   'input': '<LT>><Left>',
163 |     \   'filetype': ['lisp', 'scheme'],
164 |     \   'syntax': ['Comment', 'String'],
165 |     \ })
166 |     let b:nrule5 = Call('s:normalize_rule', {
167 |     \   'at': '\%#',
168 |     \   'char': '<LT>',
169 |     \   'input': 'This rule MUST NOT be selected.',
170 |     \   'mode': ':',
171 |     \ })
172 |     let b:nrules = [b:nrule5, b:nrule4, b:nrule3, b:nrule2, b:nrule1]
173 | 
174 |     function! b:.find(...)
175 |       return call('Call',
176 |       \           ['s:find_the_most_proper_rule_in_insert_mode'] + a:000)
177 |     endfunction
178 |   end
179 | 
180 |   after
181 |     close!
182 |   end
183 | 
184 |   it 'should fail if there is no rule for a given char'
185 |     Expect b:.find(b:nrules, '[') ==# 0
186 |   end
187 | 
188 |   it 'should check the text under the cursor by "at"'
189 |     setfiletype html
190 |     call setline(1, '(define foo )  ; ...')
191 |     Expect getline(1, line('$')) ==# ['(define foo )  ; ...']
192 | 
193 |     " (define foo #)  ; ...
194 |     normal! ggf)
195 |     Expect [line('.'), col('.')] ==# [1, 13]
196 |     Expect b:.find(b:nrules, '<') ==# b:nrule1
197 | 
198 |     " (define foo# )  ; ...
199 |     normal! ggf)h
200 |     Expect [line('.'), col('.')] ==# [1, 12]
201 |     Expect b:.find(b:nrules, '<') ==# b:nrule2
202 |   end
203 | 
204 |   it 'should check the filetype of the current buffer with "filetype"'
205 |     setfiletype scheme
206 |     call setline(1, '(define foo )  ; ...')
207 |     Expect getline(1, line('$')) ==# ['(define foo )  ; ...']
208 | 
209 |     " (define foo #)  ; ...
210 |     normal! ggf)
211 |     Expect [line('.'), col('.')] ==# [1, 13]
212 |     Expect b:.find(b:nrules, '<') ==# b:nrule3
213 | 
214 |     " (define foo# )  ; ...
215 |     normal! ggf)h
216 |     Expect [line('.'), col('.')] ==# [1, 12]
217 |     Expect b:.find(b:nrules, '<') ==# b:nrule3
218 |   end
219 | 
220 |   it 'should check the syntax name of text under the cursor with "syntax"'
221 |     setfiletype scheme
222 |     call setline(1, '(define foo )  ; ...')
223 |     Expect getline(1, line('$')) ==# ['(define foo )  ; ...']
224 | 
225 |     " (define foo #)  ; ...
226 |     normal! ggf)
227 |     Expect [line('.'), col('.')] ==# [1, 13]
228 |     Expect b:.find(b:nrules, '<') ==# b:nrule3
229 | 
230 |     " (define foo )  ; #...
231 |     normal! ggf.
232 |     Expect [line('.'), col('.')] ==# [1, 18]
233 |     Expect b:.find(b:nrules, '<') ==# b:nrule4
234 |   end
235 | end
236 | 
237 | describe 's:insert_or_replace_a_rule'
238 |   before
239 |     new
240 | 
241 |     let b:nrule_table = {}
242 |     for char in ['A', 'B', 'C', 'D', 'E', 'F']
243 |       let b:nrule_table[char] = Call('s:normalize_rule', {
244 |       \   'at': '---',
245 |       \   'char': char,
246 |       \   'input': '---',
247 |       \ })
248 |     endfor
249 | 
250 |     let b:sorted_nrules =
251 |     \ map(
252 |     \   reverse(sort(map(values(b:nrule_table), '[v:val.hash, v:val]'))),
253 |     \   'v:val[1]'
254 |     \ )
255 |   end
256 | 
257 |   after
258 |     close
259 |   end
260 | 
261 |   it 'should replace an existing value which is equivalent to the given one'
262 |     let nrule_table = {}
263 |     for char in ['A', 'B', 'C', 'D', 'E', 'F']
264 |       let nrule_table[char] = Call('s:normalize_rule', {
265 |       \   'at': '---',
266 |       \   'char': char,
267 |       \   'input': '===',
268 |       \ })
269 |     endfor
270 | 
271 |     Expect b:sorted_nrules ==# [
272 |     \   b:nrule_table['F'],
273 |     \   b:nrule_table['E'],
274 |     \   b:nrule_table['D'],
275 |     \   b:nrule_table['C'],
276 |     \   b:nrule_table['B'],
277 |     \   b:nrule_table['A'],
278 |     \ ]
279 | 
280 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['A'])
281 |     Expect b:sorted_nrules ==# [
282 |     \   b:nrule_table['F'],
283 |     \   b:nrule_table['E'],
284 |     \   b:nrule_table['D'],
285 |     \   b:nrule_table['C'],
286 |     \   b:nrule_table['B'],
287 |     \   nrule_table['A'],
288 |     \ ]
289 | 
290 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['B'])
291 |     Expect b:sorted_nrules ==# [
292 |     \   b:nrule_table['F'],
293 |     \   b:nrule_table['E'],
294 |     \   b:nrule_table['D'],
295 |     \   b:nrule_table['C'],
296 |     \   nrule_table['B'],
297 |     \   nrule_table['A'],
298 |     \ ]
299 | 
300 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['C'])
301 |     Expect b:sorted_nrules ==# [
302 |     \   b:nrule_table['F'],
303 |     \   b:nrule_table['E'],
304 |     \   b:nrule_table['D'],
305 |     \   nrule_table['C'],
306 |     \   nrule_table['B'],
307 |     \   nrule_table['A'],
308 |     \ ]
309 | 
310 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['D'])
311 |     Expect b:sorted_nrules ==# [
312 |     \   b:nrule_table['F'],
313 |     \   b:nrule_table['E'],
314 |     \   nrule_table['D'],
315 |     \   nrule_table['C'],
316 |     \   nrule_table['B'],
317 |     \   nrule_table['A'],
318 |     \ ]
319 | 
320 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['E'])
321 |     Expect b:sorted_nrules ==# [
322 |     \   b:nrule_table['F'],
323 |     \   nrule_table['E'],
324 |     \   nrule_table['D'],
325 |     \   nrule_table['C'],
326 |     \   nrule_table['B'],
327 |     \   nrule_table['A'],
328 |     \ ]
329 | 
330 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['F'])
331 |     Expect b:sorted_nrules ==# [
332 |     \   nrule_table['F'],
333 |     \   nrule_table['E'],
334 |     \   nrule_table['D'],
335 |     \   nrule_table['C'],
336 |     \   nrule_table['B'],
337 |     \   nrule_table['A'],
338 |     \ ]
339 |   end
340 | 
341 |   it 'should insert a given rule into the "sorted" position'
342 |     let nrule_table = {}
343 |     for char in ['00', 'AA', 'BB', 'CC', 'DD', 'EE', 'FF']
344 |       let nrule_table[char] = Call('s:normalize_rule', {
345 |       \   'at': '---',
346 |       \   'char': char,
347 |       \   'input': '===',
348 |       \ })
349 |     endfor
350 | 
351 |     Expect b:sorted_nrules ==# [
352 |     \   b:nrule_table['F'],
353 |     \   b:nrule_table['E'],
354 |     \   b:nrule_table['D'],
355 |     \   b:nrule_table['C'],
356 |     \   b:nrule_table['B'],
357 |     \   b:nrule_table['A'],
358 |     \ ]
359 | 
360 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['00'])
361 |     Expect b:sorted_nrules ==# [
362 |     \   b:nrule_table['F'],
363 |     \   b:nrule_table['E'],
364 |     \   b:nrule_table['D'],
365 |     \   b:nrule_table['C'],
366 |     \   b:nrule_table['B'],
367 |     \   b:nrule_table['A'],
368 |     \   nrule_table['00'],
369 |     \ ]
370 | 
371 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['AA'])
372 |     Expect b:sorted_nrules ==# [
373 |     \   b:nrule_table['F'],
374 |     \   b:nrule_table['E'],
375 |     \   b:nrule_table['D'],
376 |     \   b:nrule_table['C'],
377 |     \   b:nrule_table['B'],
378 |     \   nrule_table['AA'],
379 |     \   b:nrule_table['A'],
380 |     \   nrule_table['00'],
381 |     \ ]
382 | 
383 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['BB'])
384 |     Expect b:sorted_nrules ==# [
385 |     \   b:nrule_table['F'],
386 |     \   b:nrule_table['E'],
387 |     \   b:nrule_table['D'],
388 |     \   b:nrule_table['C'],
389 |     \   nrule_table['BB'],
390 |     \   b:nrule_table['B'],
391 |     \   nrule_table['AA'],
392 |     \   b:nrule_table['A'],
393 |     \   nrule_table['00'],
394 |     \ ]
395 | 
396 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['CC'])
397 |     Expect b:sorted_nrules ==# [
398 |     \   b:nrule_table['F'],
399 |     \   b:nrule_table['E'],
400 |     \   b:nrule_table['D'],
401 |     \   nrule_table['CC'],
402 |     \   b:nrule_table['C'],
403 |     \   nrule_table['BB'],
404 |     \   b:nrule_table['B'],
405 |     \   nrule_table['AA'],
406 |     \   b:nrule_table['A'],
407 |     \   nrule_table['00'],
408 |     \ ]
409 | 
410 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['DD'])
411 |     Expect b:sorted_nrules ==# [
412 |     \   b:nrule_table['F'],
413 |     \   b:nrule_table['E'],
414 |     \   nrule_table['DD'],
415 |     \   b:nrule_table['D'],
416 |     \   nrule_table['CC'],
417 |     \   b:nrule_table['C'],
418 |     \   nrule_table['BB'],
419 |     \   b:nrule_table['B'],
420 |     \   nrule_table['AA'],
421 |     \   b:nrule_table['A'],
422 |     \   nrule_table['00'],
423 |     \ ]
424 | 
425 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['EE'])
426 |     Expect b:sorted_nrules ==# [
427 |     \   b:nrule_table['F'],
428 |     \   nrule_table['EE'],
429 |     \   b:nrule_table['E'],
430 |     \   nrule_table['DD'],
431 |     \   b:nrule_table['D'],
432 |     \   nrule_table['CC'],
433 |     \   b:nrule_table['C'],
434 |     \   nrule_table['BB'],
435 |     \   b:nrule_table['B'],
436 |     \   nrule_table['AA'],
437 |     \   b:nrule_table['A'],
438 |     \   nrule_table['00'],
439 |     \ ]
440 | 
441 |     call Call('s:insert_or_replace_a_rule', b:sorted_nrules, nrule_table['FF'])
442 |     Expect b:sorted_nrules ==# [
443 |     \   nrule_table['FF'],
444 |     \   b:nrule_table['F'],
445 |     \   nrule_table['EE'],
446 |     \   b:nrule_table['E'],
447 |     \   nrule_table['DD'],
448 |     \   b:nrule_table['D'],
449 |     \   nrule_table['CC'],
450 |     \   b:nrule_table['C'],
451 |     \   nrule_table['BB'],
452 |     \   b:nrule_table['B'],
453 |     \   nrule_table['AA'],
454 |     \   b:nrule_table['A'],
455 |     \   nrule_table['00'],
456 |     \ ]
457 |   end
458 | 
459 |   it 'should insert a given rule as the 0th element of an empty list'
460 |     let nrules = []
461 |     Expect nrules ==# []
462 | 
463 |     call Call('s:insert_or_replace_a_rule', nrules, b:nrule_table['A'])
464 |     Expect nrules ==# [b:nrule_table['A']]
465 |   end
466 | end
467 | 
468 | describe 's:normalize_rule'
469 |   it 'should copy a given rule recursively'
470 |     let urule = {
471 |     \   'at': '\%#',
472 |     \   'char': '(',
473 |     \   'input': '()<Left>',
474 |     \   'filetype': ['foo', 'bar'],
475 |     \   'syntax': ['String', 'Comment'],
476 |     \ }
477 |     let nrule = Call('s:normalize_rule', urule)
478 | 
479 |     Expect nrule isnot urule
480 |     Expect nrule.filetype isnot urule.filetype
481 |     Expect nrule.syntax isnot urule.syntax
482 |   end
483 | 
484 |   it 'should sort "filetype" and "syntax"'
485 |     let urule = {
486 |     \   'at': '\%#',
487 |     \   'char': '(',
488 |     \   'input': '()<Left>',
489 |     \   'filetype': ['foo', 'bar'],
490 |     \   'syntax': ['String', 'Comment'],
491 |     \ }
492 |     let nrule = Call('s:normalize_rule', urule)
493 | 
494 |     Expect nrule.filetype ==# ['bar', 'foo']
495 |     Expect nrule.syntax ==# ['Comment', 'String']
496 |   end
497 | 
498 |   it 'should complete optional items'
499 |     let urule = {
500 |     \   'at': '\%#',
501 |     \   'char': '(',
502 |     \   'input': '()<Left>',
503 |     \ }
504 |     let nrule = Call('s:normalize_rule', urule)
505 | 
506 |     Expect nrule ==# {
507 |     \   'at': urule.at,
508 |     \   'char': urule.char,
509 |     \   '_char': Call('s:decode_key_notation', urule.char),
510 |     \   'input': urule.input,
511 |     \   '_input': Call('s:decode_key_notation', urule.input),
512 |     \   'mode': 'i',
513 |     \   'filetype': 0,
514 |     \   'syntax': 0,
515 |     \   'priority': 3 + 0 + 0 + 100 / 1,
516 |     \   'hash': string([printf('%06d', 3 + 0 + 0 + 100 / 1),
517 |     \                   urule.at,
518 |     \                   urule.char,
519 |     \                   0,
520 |     \                   0]),
521 |     \ }
522 |   end
523 | end
524 | 


--------------------------------------------------------------------------------
/t/proper-initialization.vim:
--------------------------------------------------------------------------------
 1 | describe 'the initialization steps'
 2 |   it 'should define the default rules fisrt, then user-defined rules'
 3 |     " Emulate stuffs in user's vimrc.
 4 |     call smartinput#define_rule({'at': '\%#', 'char': '(', 'input': 'BAR'})
 5 |     call smartinput#define_rule({'at': '', 'char': 'x', 'input': 'FOO'})
 6 |     call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
 7 | 
 8 |     " Emulate loading plugins.
 9 |     runtime! plugin/smartinput.vim
10 | 
11 |     Expect Ref('s:loaded_count') == 1
12 | 
13 |     let nrules = Ref('s:available_nrules')
14 |     let default_nrules = filter(copy(nrules), 'v:val.char !=# "x"')
15 |     let user_original_nrules = filter(copy(nrules), 'v:val.char ==# "x"')
16 |     let overridden_nrules = filter(copy(nrules),
17 |     \                              'v:val.char ==# "(" && v:val.at ==# "\\%#"')
18 |     Expect len(default_nrules) > 0
19 |     Expect len(user_original_nrules) == 1
20 |     Expect user_original_nrules[0].input ==# 'FOO'
21 |     Expect len(overridden_nrules) == 1
22 |     Expect overridden_nrules[0].input ==# 'BAR'
23 | 
24 |     Expect maparg('x', 'i') ==# ''
25 |     call smartinput#map_trigger_keys()
26 |     Expect maparg('x', 'i') !=# ''
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/t/startup-no-default-key-mappings.vim:
--------------------------------------------------------------------------------
 1 | " NB: MacVim defines several key mappings such as <D-v> by default.
 2 | " The key mappings are defined from the core, not from any runtime file.
 3 | " So that the key mappings are always defined even if Vim is invoked by
 4 | " "vim -u NONE" etc.  Remove the kay mappings to ensure that there is no key
 5 | " mappings, because some tests in this file assume such state.
 6 | imapclear
 7 | cmapclear
 8 | 
 9 | let g:smartinput_no_default_key_mappings = !0
10 | 
11 | runtime! plugin/smartinput.vim
12 | 
13 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
14 | 
15 | describe 'g:smartinput_no_default_key_mappings'
16 |   it 'should suppress to define the default key mappings'
17 |     redir => si
18 |     0 verbose imap
19 |     redir END
20 |     redir => sc
21 |     0 verbose cmap
22 |     redir END
23 | 
24 |     Expect substitute(si, '[\r\n]', '', 'g') ==# 'No mapping found'
25 |     Expect substitute(sc, '[\r\n]', '', 'g') ==# 'No mapping found'
26 |     Expect Ref('s:available_nrules') !=# []
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/t/startup-preserving-existing-key-mappings.vim:
--------------------------------------------------------------------------------
 1 | " NB: MacVim defines several key mappings such as <D-v> by default.
 2 | " The key mappings are defined from the core, not from any runtime file.
 3 | " So that the key mappings are always defined even if Vim is invoked by
 4 | " "vim -u NONE" etc.  Remove the kay mappings to ensure that there is no key
 5 | " mappings, because some tests in this file assume such state.
 6 | imapclear
 7 | cmapclear
 8 | 
 9 | inoremap (  (((
10 | cnoremap <BS>  Backspace!!!
11 | 
12 | runtime! plugin/smartinput.vim
13 | 
14 | call vspec#hint({'scope': 'smartinput#scope()', 'sid': 'smartinput#sid()'})
15 | 
16 | describe 'Start-up'
17 |   it 'should preverse existing key mappings prior to the default key mappings'
18 |     let f = {}
19 |     function! f.get_lhss(map_command)
20 |       redir => s
21 |       execute '0 verbose' a:map_command
22 |       redir END
23 |       let lhss = split(s, '\n')
24 |       call map(lhss, 'substitute(v:val, ''\v\S+\s+(\S+)\s+.*'', ''\1'', "g")')
25 |       call sort(lhss)
26 |       return lhss
27 |     endfunction
28 | 
29 |     let lhssi = f.get_lhss('imap')
30 | 
31 |     Expect lhssi ==# [
32 |     \   '"',
33 |     \   '''',
34 |     \   '(',
35 |     \   ')',
36 |     \   '<BS>',
37 |     \   '<C-H>',
38 |     \   '<CR>',
39 |     \   '<NL>',
40 |     \   '[',
41 |     \   ']',
42 |     \   '`',
43 |     \   '{',
44 |     \   '}',
45 |     \ ]
46 |     Expect maparg('(', 'i') ==# '((('
47 | 
48 |     let lhssc = f.get_lhss('cmap')
49 | 
50 |     Expect lhssc ==# [
51 |     \   '<BS>',
52 |     \   '<C-H>',
53 |     \   '<CR>',
54 |     \   '<NL>',
55 |     \ ]
56 |     Expect maparg('<BS>', 'c') ==# 'Backspace!!!'
57 |   end
58 | end
59 | 


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