vimrc/sources_non_forked/vim-snipmate/autoload/snipMate.vim

649 lines
18 KiB
VimL
Raw Normal View History

2012-08-17 03:41:25 +00:00
" config which can be overridden (shared lines)
if !exists('g:snipMate')
let g:snipMate = {}
endif
try
call tlib#input#List('mi', '', [])
catch /.*/
2017-03-14 15:16:07 +00:00
echoe "tlib is missing. See install instructions at ".expand('<sfile>:h:h').'/README.md'
2012-08-17 03:41:25 +00:00
endtry
fun! Filename(...) abort
2012-08-17 03:41:25 +00:00
let filename = expand('%:t:r')
if filename == '' | return a:0 == 2 ? a:2 : '' | endif
return !a:0 || a:1 == '' ? filename : substitute(a:1, '$1', filename, 'g')
endf
let s:cache = {}
function! snipMate#expandSnip(snip, version, col) abort
2015-02-04 10:43:54 +00:00
let lnum = line('.')
let col = a:col
let line = getline(lnum)
let indent = match(line, '\S\|$') + 1
let b:snip_state = snipmate#jumping#state()
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
if a:version == 1
let [snippet, b:snip_state.stops] = snipmate#parse#snippet(a:snip)
" Build stop/mirror info
let b:snip_state.stop_count = s:build_stops(snippet, b:snip_state.stops, lnum, col, indent)
else
let snippet = snipmate#legacy#process_snippet(a:snip)
let [b:snip_state.stops, b:snip_state.stop_count] = snipmate#legacy#build_stops(snippet, lnum, col - indent, indent)
endif
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
" Abort if the snippet is empty
if empty(snippet)
return ''
endif
2012-08-17 03:41:25 +00:00
2016-12-27 14:46:49 +00:00
let col = s:insert_snippet_text(snippet, lnum, col, indent)
2012-08-17 03:41:25 +00:00
" Open any folds snippet expands into
2015-02-04 10:43:54 +00:00
if &foldenable
silent! exec lnum . ',' . (lnum + len(snipLines) - 1) . 'foldopen'
2012-08-17 03:41:25 +00:00
endif
2015-02-04 10:43:54 +00:00
aug snipmate_changes
au CursorMoved,CursorMovedI <buffer> if exists('b:snip_state') |
\ call b:snip_state.update_changes() |
\ else |
\ silent! au! snipmate_changes * <buffer> |
\ endif
aug END
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
let b:snip_state.stop_no = 0
return b:snip_state.set_stop(0)
endfunction
2012-08-17 03:41:25 +00:00
2016-12-27 14:46:49 +00:00
function! s:insert_snippet_text(snippet, lnum, col, indent)
let line = getline(a:lnum)
let col = a:col
let snippet = type(a:snippet) == type([]) ? a:snippet : split(a:snippet, "\n", 1)
let lnum = a:lnum
" Keep text after the cursor
let afterCursor = strpart(line, col - 1)
if afterCursor != "\t" && afterCursor != ' '
let line = strpart(line, 0, col - 1)
else
let afterCursor = ''
" For some reason the cursor needs to move one right after this
if line != '' && col == 1 && &ve != 'all' && &ve != 'onemore'
let col += 1
endif
endif
call setline(lnum, '')
call append(lnum, repeat([''], len(snippet) - 1))
for item in snippet
let add = lnum == a:lnum ? line : strpart(line, 0, a:indent - 1)
if !(empty(item) || (type(item) == type([]) && empty(item[0])))
if type(item) == type([])
call setline(lnum, add .
\ snipMate#sniplist_str(item, b:snip_state.stops))
else
call setline(lnum, add .
\ substitute(item, printf('%s\d\+\|%s{\d\+.\{-}}',
\ g:snipmate#legacy#sigil, g:snipmate#legacy#sigil),
\ '', 'g'))
endif
endif
let lnum += 1
endfor
call setline(lnum - 1, getline(lnum - 1) . afterCursor)
return col
endfunction
function! snipMate#placeholder_str(num, stops) abort
2016-06-11 13:56:50 +00:00
return snipMate#sniplist_str(a:stops[a:num].placeholder, a:stops)
2015-02-04 10:43:54 +00:00
endfunction
2013-08-03 12:50:12 +00:00
function! snipMate#sniplist_str(snippet, stops) abort
2016-06-11 13:56:50 +00:00
let str = ''
2015-02-04 10:43:54 +00:00
let pos = 0
let add_to = 1
let seen_stops = []
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
while pos < len(a:snippet)
let item = a:snippet[pos]
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
if type(item) == type('')
2016-06-11 13:56:50 +00:00
let str .= item
2015-02-04 10:43:54 +00:00
elseif type(item) == type([])
2017-03-14 15:16:07 +00:00
let placeholder = snipMate#placeholder_str(item[0], a:stops)
if len(item) > 1 && type(item[1]) == type({})
let placeholder = substitute(placeholder,
\ get(item[1], 'pat', ''),
\ get(item[1], 'sub', ''),
\ get(item[1], 'flags', ''))
endif
let str .= placeholder
2012-08-17 03:41:25 +00:00
endif
2015-02-04 10:43:54 +00:00
let pos += 1
unlet item " avoid E706
endwhile
2012-08-17 03:41:25 +00:00
2016-06-11 13:56:50 +00:00
return str
endfunction
2012-08-17 03:41:25 +00:00
function! s:build_stops(snippet, stops, lnum, col, indent) abort
2015-02-04 10:43:54 +00:00
let stops = a:stops
2016-06-11 13:56:50 +00:00
let lnum = a:lnum
2015-02-04 10:43:54 +00:00
let col = a:col
2016-06-11 13:56:50 +00:00
for line in a:snippet
let col = s:build_loc_info(line, stops, lnum, col, [])
2016-06-26 11:12:36 +00:00
if line isnot a:snippet[-1]
2016-06-11 13:56:50 +00:00
let lnum += 1
let col = a:indent
2015-02-04 10:43:54 +00:00
endif
endfor
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
" add zero tabstop if it doesn't exist and then link it to the highest stop
" number
let stops[0] = get(stops, 0,
2016-06-11 13:56:50 +00:00
\ { 'placeholder' : [], 'line' : lnum, 'col' : col })
2015-02-04 10:43:54 +00:00
let stop_count = max(keys(stops)) + 2
let stops[stop_count - 1] = stops[0]
2012-08-17 03:41:25 +00:00
2015-02-04 10:43:54 +00:00
return stop_count
endfunction
2016-06-11 13:56:50 +00:00
function! s:build_loc_info(snippet, stops, lnum, col, seen_items) abort
2015-02-04 10:43:54 +00:00
let stops = a:stops
2016-06-11 13:56:50 +00:00
let lnum = a:lnum
2015-02-04 10:43:54 +00:00
let col = a:col
let pos = 0
let in_text = 0
2016-06-11 13:56:50 +00:00
let seen_items = a:seen_items
2015-02-04 10:43:54 +00:00
2016-06-11 13:56:50 +00:00
for item in a:snippet
2015-02-04 10:43:54 +00:00
if type(item) == type('')
let col += len(item)
elseif type(item) == type([])
let id = item[0]
2016-06-11 13:56:50 +00:00
let stub = item[-1]
let stub.line = lnum
let stub.col = col
call s:add_update_objects(stub, seen_items)
if len(item) > 2 && type(item[1]) != type({})
let col = s:build_loc_info(item[1:-2], stops, lnum, col, seen_items)
2015-02-04 10:43:54 +00:00
else
let col += len(snipMate#placeholder_str(id, stops))
2012-08-17 03:41:25 +00:00
endif
2016-06-11 13:56:50 +00:00
2015-02-04 10:43:54 +00:00
let in_text = 0
2012-08-17 03:41:25 +00:00
endif
2015-02-04 10:43:54 +00:00
unlet item " avoid E706
2016-06-11 13:56:50 +00:00
endfor
2013-04-26 16:17:22 +00:00
2016-06-11 13:56:50 +00:00
return col
2015-02-04 10:43:54 +00:00
endfunction
2016-06-11 13:56:50 +00:00
function! s:add_update_objects(object, targets) abort
let targets = a:targets
for item in targets
let item.update_objects = get(item, 'update_objects', [])
call add(item.update_objects, a:object)
endfor
call add(targets, a:object)
endfunction
2012-08-17 03:41:25 +00:00
" reads a .snippets file
" returns list of
" ['triggername', 'name', 'contents']
" if triggername is not set 'default' is assumed
2014-07-02 11:18:18 +00:00
" TODO: better error checking
fun! snipMate#ReadSnippetsFile(file) abort
2012-08-17 03:41:25 +00:00
let result = []
2013-07-17 23:06:05 +00:00
let new_scopes = []
if !filereadable(a:file) | return [result, new_scopes] | endif
2012-08-17 03:41:25 +00:00
let inSnip = 0
2014-07-02 11:18:18 +00:00
let line_no = 0
2015-02-04 10:43:54 +00:00
let snipversion = get(g:snipMate, 'snippet_version', 0)
2012-08-17 03:41:25 +00:00
for line in readfile(a:file) + ["\n"]
2014-07-02 11:18:18 +00:00
let line_no += 1
if inSnip && (line[0] == "\t" || line == '')
2012-08-17 03:41:25 +00:00
let content .= strpart(line, 1)."\n"
continue
elseif inSnip
2015-02-04 10:43:54 +00:00
call add(result, [trigger, name,
\ content[:-2], bang, snipversion])
2012-08-17 03:41:25 +00:00
let inSnip = 0
endif
if line[:6] == 'snippet'
let inSnip = 1
2015-02-04 10:43:54 +00:00
let bang = (line[7] == '!')
2015-12-08 13:20:04 +00:00
if bang
let bang += line[8] == '!'
endif
2015-02-04 10:43:54 +00:00
let trigger = strpart(line, 8 + bang)
2012-08-17 03:41:25 +00:00
let name = ''
let space = stridx(trigger, ' ') + 1
if space " Process multi snip
let name = strpart(trigger, space)
let trigger = strpart(trigger, 0, space - 1)
endif
let content = ''
2014-07-02 11:18:18 +00:00
if trigger =~ '^\s*$' " discard snippets with empty triggers
echom 'Invalid snippet in' a:file 'near line' line_no
let inSnip = 0
endif
2013-07-17 23:06:05 +00:00
elseif line[:6] == 'extends'
call extend(new_scopes, map(split(strpart(line, 8)),
\ "substitute(v:val, ',*$', '', '')"))
2015-02-04 10:43:54 +00:00
elseif line[:6] == 'version'
let snipversion = +strpart(line, 8)
2012-08-17 03:41:25 +00:00
endif
endfor
2013-07-17 23:06:05 +00:00
return [result, new_scopes]
2012-08-17 03:41:25 +00:00
endf
function! s:GetScopes() abort
2014-07-02 11:18:18 +00:00
let ret = exists('b:snipMate.scope_aliases') ? copy(b:snipMate.scope_aliases) : {}
2014-04-18 12:58:02 +00:00
let global = get(g:snipMate, 'scope_aliases', {})
for alias in keys(global)
if has_key(ret, alias)
let ret[alias] = join(split(ret[alias], ',')
\ + split(global[alias], ','), ',')
else
let ret[alias] = global[alias]
endif
endfor
return ret
endfunction
2012-08-17 03:41:25 +00:00
" adds scope aliases to list.
" returns new list
" the aliases of aliases are added recursively
fun! s:AddScopeAliases(list) abort
2012-08-17 03:41:25 +00:00
let did = {}
2014-04-18 12:58:02 +00:00
let scope_aliases = s:GetScopes()
2012-08-17 03:41:25 +00:00
let new = a:list
let new2 = []
while !empty(new)
for i in new
if !has_key(did, i)
let did[i] = 1
call extend(new2, split(get(scope_aliases,i,''),','))
endif
endfor
let new = new2
let new2 = []
endwhile
return keys(did)
endf
2016-03-14 10:04:57 +00:00
augroup SnipMateSource
au SourceCmd *.snippet,*.snippets call s:source_snippet()
augroup END
2015-02-04 10:43:54 +00:00
function! s:info_from_filename(file) abort
2015-02-04 10:43:54 +00:00
let parts = split(fnamemodify(a:file, ':r'), '/')
let snipidx = len(parts) - index(reverse(copy(parts)), 'snippets') - 1
let rtp_prefix = join(parts[(snipidx -
\ (parts[snipidx - 1] == 'after' ? 3 : 2)):snipidx - 1], '/')
let trigger = get(parts, snipidx + 2, '')
let desc = get(parts, snipidx + 3, get(g:snipMate, 'override', 0) ?
\ '' : fnamemodify(a:file, ':t'))
return [rtp_prefix, trigger, desc]
2013-05-26 00:31:29 +00:00
endfunction
2012-08-17 03:41:25 +00:00
function! s:source_snippet() abort
2015-02-04 10:43:54 +00:00
let file = expand('<afile>:p')
let [rtp_prefix, trigger, desc] = s:info_from_filename(file)
let new_snips = []
if fnamemodify(file, ':e') == 'snippet'
call add(new_snips, [trigger, desc, join(readfile(file), "\n"), 0,
\ get(g:snipMate, 'snippet_version', 0)])
else
let [snippets, extends] = s:CachedSnips(file)
let new_snips = deepcopy(snippets)
call extend(s:lookup_state.extends, extends)
endif
2015-02-04 10:43:54 +00:00
for snip in new_snips
if get(g:snipMate, 'override', 0)
let snip[1] = join([s:lookup_state.scope, snip[1]])
else
let snip[1] = join([s:lookup_state.scope, rtp_prefix,
\ empty(snip[1]) ? desc : snip[1]])
endif
endfor
call extend(s:lookup_state.snips, new_snips)
endfunction
function! s:CachedSnips(file) abort
let mtime = getftime(a:file)
if has_key(s:cache, a:file) && s:cache[a:file].mtime >= mtime
return s:cache[a:file].contents
endif
let s:cache[a:file] = {}
let s:cache[a:file].mtime = mtime
let s:cache[a:file].contents = snipMate#ReadSnippetsFile(a:file)
return s:cache[a:file].contents
endfunction
2012-08-17 03:41:25 +00:00
function! s:snippet_filenames(scope, trigger) abort
2015-02-04 10:43:54 +00:00
let mid = ['', '_*', '/*']
2015-02-24 10:45:22 +00:00
let mid += map(copy(mid), "'/' . a:trigger . '*' . v:val")
call map(mid, "'snippets/' . a:scope . v:val . '.snippet'")
2015-03-14 20:02:10 +00:00
return map(mid[:2], 'v:val . "s"') + mid[3:]
2015-02-04 10:43:54 +00:00
endfunction
function! snipMate#SetByPath(dict, trigger, path, snippet, bang, snipversion) abort
2015-02-04 10:43:54 +00:00
let d = a:dict
2015-12-08 13:20:04 +00:00
if a:bang == 2
unlet! d[a:trigger]
return
elseif !has_key(d, a:trigger) || a:bang == 1
2015-02-04 10:43:54 +00:00
let d[a:trigger] = {}
endif
let d[a:trigger][a:path] = [a:snippet, a:snipversion]
endfunction
2015-03-14 20:02:10 +00:00
if v:version < 704 || has('win32')
function! s:Glob(path, expr)
let res = []
for p in split(a:path, ',')
let h = split(fnamemodify(a:expr, ':h'), '/')[0]
if isdirectory(p . '/' . h)
call extend(res, split(glob(p . '/' . a:expr), "\n"))
endif
endfor
return filter(res, 'filereadable(v:val)')
endfunction
else
function! s:Glob(path, expr)
return split(globpath(a:path, a:expr), "\n")
endfunction
endif
2012-08-17 03:41:25 +00:00
" default triggers based on paths
function! snipMate#DefaultPool(scopes, trigger, result) abort
2015-02-04 10:43:54 +00:00
let scopes = s:AddScopeAliases(a:scopes)
let scopes_done = []
let s:lookup_state = {}
let s:lookup_state.snips = []
while !empty(scopes)
let scope = remove(scopes, 0)
let s:lookup_state.scope = scope
let s:lookup_state.extends = []
2015-03-14 20:02:10 +00:00
for expr in s:snippet_filenames(scope, escape(a:trigger, "*[]?{}`'$|#%"))
for path in s:snippet_dirs()
2015-03-14 20:02:10 +00:00
for file in s:Glob(path, expr)
source `=file`
endfor
endfor
endfor
2015-02-04 10:43:54 +00:00
call add(scopes_done, scope)
call extend(scopes, s:lookup_state.extends)
call filter(scopes, 'index(scopes_done, v:val) == -1')
endwhile
for [trigger, desc, contents, bang, snipversion] in s:lookup_state.snips
if trigger =~ '\V\^' . escape(a:trigger, '\')
call snipMate#SetByPath(a:result, trigger, desc, contents, bang, snipversion)
2012-08-17 03:41:25 +00:00
endif
endfor
endfunction
2012-08-17 03:41:25 +00:00
" return a dict of snippets found in runtimepath matching trigger
" scopes: list of scopes. usually this is the filetype. eg ['c','cpp']
" trigger may contain glob patterns. Thus use '*' to get all triggers
"
fun! snipMate#GetSnippets(scopes, trigger) abort
2012-08-17 03:41:25 +00:00
let result = {}
for F in values(g:snipMateSources)
call funcref#Call(F, [a:scopes, a:trigger, result])
endfor
return result
endf
function! s:snippet_dirs() abort
return get(g:snipMate, 'snippet_dirs', split(&rtp, ','))
endfunction
2015-03-14 20:02:10 +00:00
function! snipMate#OpenSnippetFiles() abort
let files = []
let scopes_done = []
let exists = []
let notexists = []
for scope in s:AddScopeAliases(snipMate#ScopesByFile())
2015-07-13 10:22:46 +00:00
let files += s:snippet_filenames(scope, '')
2012-08-17 03:41:25 +00:00
endfor
2015-03-14 20:02:10 +00:00
call filter(files, "v:val !~# '\\*'")
for path in s:snippet_dirs()
2015-03-14 20:02:10 +00:00
let fullpaths = map(copy(files), 'printf("%s/%s", path, v:val)')
let exists += filter(copy(fullpaths), 'filereadable(v:val)')
let notexists += map(filter(copy(fullpaths),
\ 'v:val =~# "\.snippets" && !filereadable(v:val)'),
\ '"does not exist: " . v:val')
endfor
let all = exists + notexists
let select = tlib#input#List('mi', 'select files to be opened in splits', all)
for idx in select
exec 'sp' all[idx - 1]
endfor
endfunction
2012-08-17 03:41:25 +00:00
fun! snipMate#ScopesByFile() abort
2012-08-17 03:41:25 +00:00
" duplicates are removed in AddScopeAliases
2014-04-18 12:58:02 +00:00
return filter(funcref#Call(g:snipMate.get_scopes), "v:val != ''")
2012-08-17 03:41:25 +00:00
endf
" used by both: completion and insert snippet
fun! snipMate#GetSnippetsForWordBelowCursor(word, exact) abort
2015-12-08 13:20:04 +00:00
" Split non-word characters into their own piece
" so 'foo.bar..baz' becomes ['foo', '.', 'bar', '.', '.', 'baz']
" First split just after a \W and then split each resultant string just
" before a \W
let parts = filter(tlib#list#Flatten(
\ map(split(a:word, '\W\zs'), 'split(v:val, "\\ze\\W")')),
\ '!empty(v:val)')
2015-02-04 10:43:54 +00:00
" Only look at the last few possibilities. Too many can be slow.
if len(parts) > 5
let parts = parts[-5:]
2012-08-17 03:41:25 +00:00
endif
let lookups = [a:word]
2012-08-17 03:41:25 +00:00
let lookup = ''
for w in reverse(parts)
let lookup = w . lookup
if index(lookups, lookup) == -1
call add(lookups, lookup)
2012-08-17 03:41:25 +00:00
endif
endfor
" Remove empty lookup entries, but only if there are other nonempty lookups
if len(lookups) > 1
call filter(lookups, 'v:val != ""')
endif
2012-08-17 03:41:25 +00:00
let matching_snippets = []
let snippet = ''
" prefer longest word
for word in lookups
2014-04-18 12:58:02 +00:00
let g:snipMate.word = word
for [k,snippetD] in items(funcref#Call(g:snipMate['get_snippets'], [snipMate#ScopesByFile(), word]))
" hack: require exact match
if a:exact && k !=# word
continue
2012-08-17 03:41:25 +00:00
endif
call add(matching_snippets, [k, snippetD])
if a:exact
break
endif
2012-08-17 03:41:25 +00:00
endfor
endfor
return matching_snippets
endf
" snippets: dict containing snippets by name
" usually this is just {'default' : snippet_contents }
fun! s:ChooseSnippet(snippets) abort
2012-08-17 03:41:25 +00:00
let snippet = []
let keys = keys(a:snippets)
let i = 1
for snip in keys
let snippet += [i.'. '.snip]
let i += 1
endfor
if len(snippet) == 1
" there's only a single snippet, choose it
let idx = 0
else
let idx = tlib#input#List('si','select snippet by name',snippet) -1
if idx == -1
return ''
endif
endif
" if a:snippets[..] is a String Call returns it
" If it's a function or a function string the result is returned
return funcref#Call(a:snippets[keys(a:snippets)[idx]])
endf
fun! snipMate#WordBelowCursor() abort
return matchstr(getline('.'), '\S\+\%' . col('.') . 'c')
endf
fun! snipMate#GetSnippetsForWordBelowCursorForComplete(word) abort
2016-10-02 11:37:21 +00:00
let matches = snipMate#GetSnippetsForWordBelowCursor(a:word, 0)
let snippets = []
for [trigger, dict] in matches
if get(g:snipMate, 'description_in_completion', 0)
call extend(snippets, map(keys(dict),
\ '{ "word" : trigger, "menu" : v:val, "dup" : 1 }'))
else
call add(snippets, { "word" : trigger })
endif
endfor
return filter(snippets,
\ 'v:val.word =~# "\\V\\^' . escape(a:word, '"\') . '"')
endf
fun! snipMate#CanBeTriggered() abort
let word = snipMate#WordBelowCursor()
let matches = snipMate#GetSnippetsForWordBelowCursorForComplete(word)
return len(matches) > 0
endf
fun! snipMate#ShowAvailableSnips() abort
let col = col('.')
let word = snipMate#WordBelowCursor()
let matches = snipMate#GetSnippetsForWordBelowCursorForComplete(word)
2012-08-17 03:41:25 +00:00
" Pretty hacky, but really can't have the tab swallowed!
if len(matches) == 0
2014-04-18 12:58:02 +00:00
call feedkeys(g:snipMate['no_match_completion_feedkeys_chars'], 'n')
2012-08-17 03:41:25 +00:00
return ""
endif
call complete(col - len(word), sort(matches))
2012-08-17 03:41:25 +00:00
return ''
endf
" Pass an argument to force snippet expansion instead of triggering or jumping
function! snipMate#TriggerSnippet(...) abort
2012-08-17 03:41:25 +00:00
if exists('g:SuperTabMappingForward')
if g:SuperTabMappingForward == "<tab>"
let SuperTabPlug = maparg('<Plug>SuperTabForward', 'i')
if SuperTabPlug == ""
let SuperTabKey = "\<c-n>"
else
exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
endif
elseif g:SuperTabMappingBackward == "<tab>"
let SuperTabPlug = maparg('<Plug>SuperTabBackward', 'i')
if SuperTabPlug == ""
let SuperTabKey = "\<c-p>"
else
exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
endif
endif
endif
if pumvisible() " Update snippet if completion is used, or deal with supertab
if exists('SuperTabKey')
call feedkeys(SuperTabKey) | return ''
endif
call feedkeys("\<esc>a", 'n') " Close completion menu
call feedkeys("\<tab>") | return ''
endif
if exists('b:snip_state') && a:0 == 0 " Jump only if no arguments
let jump = b:snip_state.jump_stop(0)
if type(jump) == 1 " returned a string
return jump
endif
endif
2012-08-17 03:41:25 +00:00
let word = matchstr(getline('.'), '\S\+\%'.col('.').'c')
let list = snipMate#GetSnippetsForWordBelowCursor(word, 1)
2012-08-17 03:41:25 +00:00
if empty(list)
let snippet = ''
else
let [trigger, snippetD] = list[0]
2015-02-04 10:43:54 +00:00
let snippet = s:ChooseSnippet(snippetD)
" Before expanding snippet, create new undo point |i_CTRL-G|
let &undolevels = &undolevels
2012-08-17 03:41:25 +00:00
let col = col('.') - len(trigger)
sil exe 's/\V'.escape(trigger, '/\.').'\%#//'
2015-02-04 10:43:54 +00:00
return snipMate#expandSnip(snippet[0], snippet[1], col)
2012-08-17 03:41:25 +00:00
endif
" should allow other plugins to register hooks instead (duplicate code)
if exists('SuperTabKey')
call feedkeys(SuperTabKey)
return ''
endif
return word == ''
\ ? "\<tab>"
\ : "\<c-r>=snipMate#ShowAvailableSnips()\<cr>"
endfunction
2012-08-17 03:41:25 +00:00
fun! snipMate#BackwardsSnippet() abort
if exists('b:snip_state') | return b:snip_state.jump_stop(1) | endif
2012-08-17 03:41:25 +00:00
if exists('g:SuperTabMappingForward')
if g:SuperTabMappingForward == "<s-tab>"
let SuperTabPlug = maparg('<Plug>SuperTabForward', 'i')
if SuperTabPlug == ""
let SuperTabKey = "\<c-n>"
else
exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
endif
elseif g:SuperTabMappingBackward == "<s-tab>"
let SuperTabPlug = maparg('<Plug>SuperTabBackward', 'i')
if SuperTabPlug == ""
let SuperTabKey = "\<c-p>"
else
exec "let SuperTabKey = \"" . escape(SuperTabPlug, '<') . "\""
endif
endif
endif
" should allow other plugins to register hooks instead (duplicate code)
if exists('SuperTabKey')
call feedkeys(SuperTabKey)
return ''
endif
return "\<s-tab>"
endf
" vim:noet:sw=4:ts=4:ft=vim