diff options
Diffstat (limited to 'vim/bundle/vim-snipmate')
22 files changed, 0 insertions, 2854 deletions
diff --git a/vim/bundle/vim-snipmate b/vim/bundle/vim-snipmate new file mode 160000 +Subproject ee433e43c76c768c95ad6d9af67c4cd4b40f7ea diff --git a/vim/bundle/vim-snipmate/.gitignore b/vim/bundle/vim-snipmate/.gitignore deleted file mode 100644 index 9140e6a..0000000 --- a/vim/bundle/vim-snipmate/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -doc/tags -*.swp -.DS_Store diff --git a/vim/bundle/vim-snipmate/Contributors.md b/vim/bundle/vim-snipmate/Contributors.md deleted file mode 100644 index 4206472..0000000 --- a/vim/bundle/vim-snipmate/Contributors.md +++ /dev/null @@ -1,52 +0,0 @@ -# Contributors # - -SnipMate was originally authored by Michael Sanders -([Vim](http://www.vim.org/account/profile.php?user_id=16544), -[GitHub](https://github.com/msanders)). - -It is currently maintained by [Rok Garbas](rok@garbas.si), [Marc -Weber](marco-oweber@gmx.de), and [Adnan Zafar](https://github.com/ajzafar) with -additional contributions from: - -* [907th](https://github.com/907th) -* [adkron](https://github.com/adkron) -* [alderz](https://github.com/alderz) -* [asymmetric](https://github.com/asymmetric) -* [bpugh](https://github.com/bpugh) -* [bruno-](https://github.com/bruno-) -* [CharlesGueunet](https://github.com/CharlesGueunet) -* [darkwise](https://github.com/darkwise) -* [dreviejo](https://github.com/dreviejo) -* [fish-face](https://github.com/fish-face) -* [henrik](https://github.com/henrik) -* [holizz](https://github.com/holizz) -* [honza](https://github.com/honza) -* [hpesoj](https://github.com/hpesoj) -* [ironcamel](https://github.com/ironcamel) -* [jb55](https://github.com/jb55) -* [jbernard](https://github.com/jbernard) -* [jherdman](https://github.com/jherdman) -* [kozo2](https://github.com/kozo2) -* [lilydjwg](https://github.com/lilydjwg) -* [lpil](https://github.com/lpil) -* [marutanm](https://github.com/marutanm) -* [MicahElliott](https://github.com/MicahElliott) -* [mikeastock](https://github.com/mikeastock) -* [muffinresearch](https://github.com/muffinresearch) -* [munyari](https://github.com/munyari) -* [pielgrzym](https://github.com/pielgrzym) -* [pose](https://github.com/pose) -* [r00k](https://github.com/r00k) -* [radicalbit](https://github.com/radicalbit) -* [redpill](https://github.com/redpill) -* [rglassett](http://github.com/rglassett) -* [robhudson](https://github.com/robhudson) -* [shinymayhem](https://github.com/shinymayhem) -* [Shraymonks](https://github.com/shraymonks) -* [sickill](https://github.com/sickill) -* [statik](https://github.com/statik) -* [steveno](https://github.com/steveno) -* [taq](https://github.com/taq) -* [thisgeek](https://github.com/thisgeek) -* [trusktr](https://github.com/trusktr) -* [Xandaros](https://github.com/Xandaros) diff --git a/vim/bundle/vim-snipmate/README.md b/vim/bundle/vim-snipmate/README.md deleted file mode 100644 index b47b56d..0000000 --- a/vim/bundle/vim-snipmate/README.md +++ /dev/null @@ -1,169 +0,0 @@ -# SnipMate # - -SnipMate aims to provide support for textual snippets, similar to TextMate or -other Vim plugins like [UltiSnips][ultisnips]. For -example, in C, typing `for<tab>` could be expanded to - - for (i = 0; i < count; i++) { - /* code */ - } - -with successive presses of tab jumping around the snippet. - -Originally authored by [Michael Sanders][msanders], SnipMate was forked in 2011 -after a stagnation in development. This fork is currently maintained by [Rok -Garbas][garbas], [Marc Weber][marcweber], and [Adnan Zafar][ajzafar]. - - -## Installing SnipMate ## - -We recommend one of the following methods for installing SnipMate and its -dependencies. SnipMate depends on [vim-addon-mw-utils][mw-utils] and -[tlib][tlib]. - -> **NOTE:** SnipMate does not ship with any snippets out of the box. We suggest -looking at the [vim-snippets][vim-snippets] repository. - -* Using [VAM][vam], add `vim-snippets` to the list of packages to be installed. - -* Using [Pathogen][pathogen], run the following commands: - - % cd ~/.vim/bundle - % git clone https://github.com/tomtom/tlib_vim.git - % git clone https://github.com/MarcWeber/vim-addon-mw-utils.git - % git clone https://github.com/garbas/vim-snipmate.git - - # Optional: - % git clone https://github.com/honza/vim-snippets.git - -* Using [Vundle][vundle], add the following to your `vimrc` then run - `:PluginInstall` - - Plugin 'MarcWeber/vim-addon-mw-utils' - Plugin 'tomtom/tlib_vim' - Plugin 'garbas/vim-snipmate' - - " Optional: - Plugin 'honza/vim-snippets' - -## FAQ ## - -> SnipMate doesn't work / My snippets aren't triggering - -Try all of the following: - -* Check that SnipMate is loaded. This can be done by looking for - `<Plug>snipMateTrigger` and similar maps in the output of `:imap`. - Additionally make sure either `<Plug>snipMateTrigger` or - `<Plug>snipMateNextOrTrigger` is mapped to the key you expect. - -* Check that the snippets file you mean to use exists, and that it contains the - snippet you're trying to expand. - -* Check that your snippets file is located inside a `foo/snippets` directory, - where `foo` is a path listed in your `runtimepath`. - -* Check that your snippets file is in scope by either the filetype matching the - path of the snippet file or the scope explicitly loaded. - -* Check if any snippets from your snippets file are available. This can be done - with the "show available snips" map, by default bound to `<C-R><Tab>` in - insert mode. - -If all of the above check out, please open an issue stating your Vim version, -a sample snippet, and a description of exactly what happens when you try to -trigger a snippet. - -> How does SnipMate determine which snippets to load? How can I separate, for -> example, my Rails snippets from my Ruby snippets? - -Primarily SnipMate looks at the `'filetype'` and `'syntax'` settings. Taking -"scopes" from these options, it looks in each `snippets/` directory in -`'runtimepath'` for files named `scope.snippets`, `scope/*.snippets`, or -`scope_*.snippets`. - -However we understand this may not allow for the flexibility desired by some -languages. For this we provide two options: scope aliases and the -`:SnipMateLoadScope` command. Scope aliases simply say "whenever this scope is -loaded, also load this other scope: - - let g:snipMate = get(g:, 'snipMate', {}) " Allow for vimrc re-sourcing - let g:snipMate.scope_aliases = {} - let g:snipMate.scope_aliases['ruby'] = 'ruby,rails' - -will load the `ruby-rails` scope whenever the `ruby` scope is active. The -`:SnipMateLoadScope foo` command will always load the foo scope in the current -buffer. The [vim-rails](https://github.com/tpope/vim-rails) plugin automatically -does `:SnipMateLoadScope rails` when editing a Rails project for example. - -## Release Notes ## - -### 0.89 - 2016-05-29 ### - -* Various regex updates to legacy parser -* Addition of double bang syntax to completely remove a snippet from lookup -* Group various SnipMate autocommands -* Support setting 'shiftwidth' to 0 -* Parser now operates linewise, adding some flexibility -* Mirror substitutions are more literal -* Mirror length is calculated correctly when substitutions occur - -### 0.88 - 2015-04-04 ### - -* Implement simple caching -* Remove expansion guards -* Add `:SnipMateLoadScope` command and buffer-local scope aliases -* Load `<scope>_*.snippets` files -* Use CursorMoved autocmd events entirely - -* The nested branch has been merged - * A new snippet parser has been added. The g:snipmate.version as well as - version lines in snippet files determines which is used - * The new parser supports tab stops placed within placeholders, - substitutions, non-consecutive stop numbers, and fewer ambiguities - * The stop jumping code has been updated - * Tests have been added for the jumping code and the new parser - -* The override branch has been merged - * The g:snipMate.override option is added. When enabled, if two snippets - share the same name, the later-loaded one is kept and the other discarded - * Override behavior can be enabled on a per-snippet basis with a bang (!) in - the snippet file - * Otherwise, SnipMate tries to preserve all snippets loaded - -* Fix bug with mirrors in the first column -* Fix bug with tabs in indents ([#143][143]) -* Fix bug with mirrors in placeholders -* Fix reading single snippet files -* Fix the use of the visual map at the end of a line -* Fix expansion of stops containing only the zero tab stop -* Remove select mode mappings -* Indent visual placeholder expansions and remove extraneous lines ([#177][177] - and [#178][178]) - -### 0.87 - 2014-01-04 ### - -* Stop indenting empty lines when expanding snippets -* Support extends keyword in .snippets files -* Fix visual placeholder support -* Add zero tabstop support -* Support negative 'softtabstop' -* Add g:snipMate_no_default_aliases option -* Add <Plug>snipMateTrigger for triggering an expansion inside a snippet -* Add snipMate#CanBeTriggered() function - -[ultisnips]: https://github.com/sirver/ultisnips -[msanders]: https://github.com/msanders -[garbas]: https://github.com/garbas -[marcweber]: https://github.com/marcweber -[ajzafar]: https://github.com/ajzafar -[mw-utils]: https://github.com/marcweber/vim-addon-mw-utils -[tlib]: https://github.com/tomtom/tlib_vim -[vim-snippets]: https://github.com/honza/vim-snippets -[vam]: https://github.com/marcweber/vim-addon-manager -[pathogen]: https://github.com/tpope/vim-pathogen -[vundle]: https://github.com/gmarik/vundle - -[143]: https://github.com/garbas/vim-snipmate/issues/143 -[177]: https://github.com/garbas/vim-snipmate/issues/177 -[178]: https://github.com/garbas/vim-snipmate/issues/178 diff --git a/vim/bundle/vim-snipmate/addon-info.json b/vim/bundle/vim-snipmate/addon-info.json deleted file mode 100644 index 8d9930f..0000000 --- a/vim/bundle/vim-snipmate/addon-info.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "name" : "snipMate", - "version" : "dev", - "author" : "Michael Sanders -> original project http://github.com/msanders/snipmate.vim", - "maintainer" : "Rok Garbas / Marc Weber", - "repository" : {"type": "git", "url": "git://github.com/garbas/vim-snipmate.git"}, - "dependencies" : { - "vim-addon-mw-utils": {}, - "tlib": {} - }, - "description" : "snipMate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim. See README.md to learn about the features this fork adds" -} diff --git a/vim/bundle/vim-snipmate/after/plugin/snipMate.vim b/vim/bundle/vim-snipmate/after/plugin/snipMate.vim deleted file mode 100644 index 3d6bac7..0000000 --- a/vim/bundle/vim-snipmate/after/plugin/snipMate.vim +++ /dev/null @@ -1,46 +0,0 @@ -" snipMate maps -" These maps are created here in order to make sure we can reliably create maps -" after SuperTab. - -let s:save_cpo = &cpo -set cpo&vim - -function! s:map_if_not_mapped(lhs, rhs, mode) abort - let l:unique = s:overwrite ? '' : ' <unique>' - if !hasmapto(a:rhs, a:mode) - silent! exe a:mode . 'map' . l:unique a:lhs a:rhs - endif -endfunction - -if !exists('g:snips_no_mappings') || !g:snips_no_mappings - if exists('g:snips_trigger_key') - echom 'g:snips_trigger_key is deprecated. See :h snipMate-mappings' - exec 'imap <unique>' g:snips_trigger_key '<Plug>snipMateTrigger' - exec 'smap <unique>' g:snips_trigger_key '<Plug>snipMateSNext' - exec 'xmap <unique>' g:snips_trigger_key '<Plug>snipMateVisual' - else - " Remove SuperTab map if it exists - let s:overwrite = maparg('<Tab>', 'i') ==? '<Plug>SuperTabForward' - call s:map_if_not_mapped('<Tab>', '<Plug>snipMateNextOrTrigger', 'i') - call s:map_if_not_mapped('<Tab>', '<Plug>snipMateNextOrTrigger', 's') - let s:overwrite = 0 - call s:map_if_not_mapped('<Tab>', '<Plug>snipMateVisual', 'x') - endif - - if exists('g:snips_trigger_key_backwards') - echom 'g:snips_trigger_key_backwards is deprecated. See :h snipMate-mappings' - exec 'imap <unique>' g:snips_trigger_key_backwards '<Plug>snipMateIBack' - exec 'smap <unique>' g:snips_trigger_key_backwards '<Plug>snipMateSBack' - else - let s:overwrite = maparg('<S-Tab>', 'i') ==? '<Plug>SuperTabBackward' - call s:map_if_not_mapped('<S-Tab>', '<Plug>snipMateBack', 'i') - call s:map_if_not_mapped('<S-Tab>', '<Plug>snipMateBack', 's') - let s:overwrite = 0 - endif - - call s:map_if_not_mapped('<C-R><Tab>', '<Plug>snipMateShow', 'i') -endif - -let &cpo = s:save_cpo - -" vim:noet: diff --git a/vim/bundle/vim-snipmate/autoload/snipMate.vim b/vim/bundle/vim-snipmate/autoload/snipMate.vim deleted file mode 100644 index 74366fa..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipMate.vim +++ /dev/null @@ -1,603 +0,0 @@ -" config which can be overridden (shared lines) -if !exists('g:snipMate') - let g:snipMate = {} -endif - -try - call tlib#input#List('mi', '', []) -catch /.*/ - echoe "you're missing tlib. See install instructions at ".expand('<sfile>:h:h').'/README.md' -endtry - -fun! Filename(...) abort - 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 - let lnum = line('.') - let col = a:col - let line = getline(lnum) - let indent = match(line, '\S\|$') + 1 - let b:snip_state = snipmate#jumping#state() - - 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) - let snipLines = map(copy(snippet), - \ 'snipMate#sniplist_str(v:val, b:snip_state.stops)') - 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) - let snipLines = split(substitute(snippet, printf('%s\d\+\|%s{\d\+.\{-}}', - \ g:snipmate#legacy#sigil, g:snipmate#legacy#sigil), '', 'g'), "\n", 1) - endif - - " Abort if the snippet is empty - if empty(snippet) - return '' - endif - - " Expand snippet onto current position - let afterCursor = strpart(line, col - 1) - " Keep text after the cursor - if afterCursor != "\t" && afterCursor != ' ' - let line = strpart(line, 0, col - 1) - let snipLines[-1] .= afterCursor - 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 - - " Insert snippet with proper indentation - call setline(lnum, line . snipLines[0]) - call append(lnum, map(snipLines[1:], "empty(v:val) ? v:val : '" . strpart(line, 0, indent - 1) . "' . v:val")) - - " Open any folds snippet expands into - if &foldenable - silent! exec lnum . ',' . (lnum + len(snipLines) - 1) . 'foldopen' - endif - - 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 - - let b:snip_state.stop_no = 0 - return b:snip_state.set_stop(0) -endfunction - -function! snipMate#placeholder_str(num, stops) abort - return snipMate#sniplist_str(a:stops[a:num].placeholder, a:stops) -endfunction - -function! snipMate#sniplist_str(snippet, stops) abort - let str = '' - let pos = 0 - let add_to = 1 - let seen_stops = [] - - while pos < len(a:snippet) - let item = a:snippet[pos] - - if type(item) == type('') - let str .= item - elseif type(item) == type([]) - let str .= snipMate#placeholder_str(item[0], a:stops) - endif - - let pos += 1 - unlet item " avoid E706 - endwhile - - return str -endfunction - -function! s:build_stops(snippet, stops, lnum, col, indent) abort - let stops = a:stops - let lnum = a:lnum - let col = a:col - - for line in a:snippet - let col = s:build_loc_info(line, stops, lnum, col, []) - if line isnot a:snippet[-1] - let lnum += 1 - let col = a:indent - endif - endfor - - " add zero tabstop if it doesn't exist and then link it to the highest stop - " number - let stops[0] = get(stops, 0, - \ { 'placeholder' : [], 'line' : lnum, 'col' : col }) - let stop_count = max(keys(stops)) + 2 - let stops[stop_count - 1] = stops[0] - - return stop_count -endfunction - -function! s:build_loc_info(snippet, stops, lnum, col, seen_items) abort - let stops = a:stops - let lnum = a:lnum - let col = a:col - let pos = 0 - let in_text = 0 - let seen_items = a:seen_items - - for item in a:snippet - if type(item) == type('') - let col += len(item) - elseif type(item) == type([]) - let id = item[0] - 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) - else - let col += len(snipMate#placeholder_str(id, stops)) - endif - - let in_text = 0 - endif - unlet item " avoid E706 - endfor - - return col -endfunction - -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 - -" reads a .snippets file -" returns list of -" ['triggername', 'name', 'contents'] -" if triggername is not set 'default' is assumed -" TODO: better error checking -fun! snipMate#ReadSnippetsFile(file) abort - let result = [] - let new_scopes = [] - if !filereadable(a:file) | return [result, new_scopes] | endif - let inSnip = 0 - let line_no = 0 - let snipversion = get(g:snipMate, 'snippet_version', 0) - for line in readfile(a:file) + ["\n"] - let line_no += 1 - - if inSnip && (line[0] == "\t" || line == '') - let content .= strpart(line, 1)."\n" - continue - elseif inSnip - call add(result, [trigger, name, - \ content[:-2], bang, snipversion]) - let inSnip = 0 - endif - - if line[:6] == 'snippet' - let inSnip = 1 - let bang = (line[7] == '!') - if bang - let bang += line[8] == '!' - endif - let trigger = strpart(line, 8 + bang) - 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 = '' - if trigger =~ '^\s*$' " discard snippets with empty triggers - echom 'Invalid snippet in' a:file 'near line' line_no - let inSnip = 0 - endif - elseif line[:6] == 'extends' - call extend(new_scopes, map(split(strpart(line, 8)), - \ "substitute(v:val, ',*$', '', '')")) - elseif line[:6] == 'version' - let snipversion = +strpart(line, 8) - endif - endfor - return [result, new_scopes] -endf - -function! s:GetScopes() abort - let ret = exists('b:snipMate.scope_aliases') ? copy(b:snipMate.scope_aliases) : {} - 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 - -" adds scope aliases to list. -" returns new list -" the aliases of aliases are added recursively -fun! s:AddScopeAliases(list) abort - let did = {} - let scope_aliases = s:GetScopes() - 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 - -augroup SnipMateSource - au SourceCmd *.snippet,*.snippets call s:source_snippet() -augroup END - -function! s:info_from_filename(file) abort - 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] -endfunction - -function! s:source_snippet() abort - 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 - 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 - -function! s:snippet_filenames(scope, trigger) abort - let mid = ['', '_*', '/*'] - let mid += map(copy(mid), "'/' . a:trigger . '*' . v:val") - call map(mid, "'snippets/' . a:scope . v:val . '.snippet'") - return map(mid[:2], 'v:val . "s"') + mid[3:] -endfunction - -function! snipMate#SetByPath(dict, trigger, path, snippet, bang, snipversion) abort - let d = a:dict - if a:bang == 2 - unlet! d[a:trigger] - return - elseif !has_key(d, a:trigger) || a:bang == 1 - let d[a:trigger] = {} - endif - let d[a:trigger][a:path] = [a:snippet, a:snipversion] -endfunction - -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 - -" default triggers based on paths -function! snipMate#DefaultPool(scopes, trigger, result) abort - 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 = [] - - for expr in s:snippet_filenames(scope, escape(a:trigger, "*[]?{}`'$|#%")) - for path in g:snipMate.snippet_dirs - for file in s:Glob(path, expr) - source `=file` - endfor - endfor - endfor - - 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) - endif - endfor -endfunction - -" 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 - let result = {} - - for F in values(g:snipMateSources) - call funcref#Call(F, [a:scopes, a:trigger, result]) - endfor - return result -endf - -function! snipMate#OpenSnippetFiles() abort - let files = [] - let scopes_done = [] - let exists = [] - let notexists = [] - for scope in s:AddScopeAliases(snipMate#ScopesByFile()) - let files += s:snippet_filenames(scope, '') - endfor - call filter(files, "v:val !~# '\\*'") - for path in g:snipMate.snippet_dirs - 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 - -fun! snipMate#ScopesByFile() abort - " duplicates are removed in AddScopeAliases - return filter(funcref#Call(g:snipMate.get_scopes), "v:val != ''") -endf - -" used by both: completion and insert snippet -fun! snipMate#GetSnippetsForWordBelowCursor(word, exact) abort - " 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)') - " Only look at the last few possibilities. Too many can be slow. - if len(parts) > 5 - let parts = parts[-5:] - endif - let lookups = [a:word] - let lookup = '' - for w in reverse(parts) - let lookup = w . lookup - if index(lookups, lookup) == -1 - call add(lookups, lookup) - endif - endfor - - " Remove empty lookup entries, but only if there are other nonempty lookups - if len(lookups) > 1 - call filter(lookups, 'v:val != ""') - endif - - let matching_snippets = [] - let snippet = '' - " prefer longest word - for word in lookups - 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 - endif - call add(matching_snippets, [k, snippetD]) - if a:exact - break - endif - endfor - endfor - return matching_snippets -endf - -" snippets: dict containing snippets by name -" usually this is just {'default' : snippet_contents } -fun! s:ChooseSnippet(snippets) abort - 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 - let snippets = map(snipMate#GetSnippetsForWordBelowCursor(a:word, 0), 'v:val[0]') - return filter(snippets, 'v:val =~# "\\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) - - " Pretty hacky, but really can't have the tab swallowed! - if len(matches) == 0 - call feedkeys(g:snipMate['no_match_completion_feedkeys_chars'], 'n') - return "" - endif - - call complete(col - len(word), sort(matches)) - return '' -endf - -" Pass an argument to force snippet expansion instead of triggering or jumping -function! snipMate#TriggerSnippet(...) abort - 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 - - let word = matchstr(getline('.'), '\S\+\%'.col('.').'c') - let list = snipMate#GetSnippetsForWordBelowCursor(word, 1) - if empty(list) - let snippet = '' - else - let [trigger, snippetD] = list[0] - let snippet = s:ChooseSnippet(snippetD) - " Before expanding snippet, create new undo point |i_CTRL-G| - let &undolevels = &undolevels - let col = col('.') - len(trigger) - sil exe 's/\V'.escape(trigger, '/\.').'\%#//' - return snipMate#expandSnip(snippet[0], snippet[1], col) - 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 - -fun! snipMate#BackwardsSnippet() abort - if exists('b:snip_state') | return b:snip_state.jump_stop(1) | endif - - 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 diff --git a/vim/bundle/vim-snipmate/autoload/snipMate_python_demo.vim b/vim/bundle/vim-snipmate/autoload/snipMate_python_demo.vim deleted file mode 100644 index de495d2..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipMate_python_demo.vim +++ /dev/null @@ -1,47 +0,0 @@ -" This file demonstrates -" - how to register your own snippet sources (call snipMate_python_demo#Activate() in ftplugin/python.vim) -" - implents a source which creates snippets based on python function -" definitions found in the current file -" -" Example: -" -" def abc(a,b,c=None) -" will create a snippet on the fly which looks like this: -" abc(${1:a}, ${2:b}, ${3:c=None}) - -fun! snipMate_python_demo#Activate() abort - if !exists('g:snipMateSources') - let g:snipMateSources = {} - endif - - let g:snipMateSources['python'] = funcref#Function('snipMate_python_demo#FunctionsFromCurrentFileAndTags') -endf - -fun! s:Add(dict, line, source, trigger) abort - let matched = matchlist(a:line,'def\s\+\([^( \t]\+\)[ \t]*(\([^)]*\)') - if len(matched) > 2 - let name = matched[1] - " TODO: is this a glob? - if name !~ a:trigger | return | endif - let a:dict[name] = get(a:dict, name, {}) - let sd = a:dict[name] - let args = [] - let nr=1 - for arg in split(matched[2], '\s*,\s*') - call add(args, '${'.nr.':'.arg.'}') - let nr+=1 - endfor - let sd[a:source] = name.'('.join(args,', ').')' - endif -endf -fun! snipMate_python_demo#FunctionsFromCurrentFileAndTags(scopes, trigger, result) abort - " getting all might be too much - if a:trigger == '*' | return | endif - if index(a:scopes, 'python') < 0 | return | endif - for t in taglist('^'.a:trigger) - call s:Add(a:result, t.cmd, 'tags-' . t.filename, a:trigger) - endfor - for l in getline(0, line('$')) - call s:Add(a:result, l, 'current-file', a:trigger) - endfor -endf diff --git a/vim/bundle/vim-snipmate/autoload/snipmate/jumping.vim b/vim/bundle/vim-snipmate/autoload/snipmate/jumping.vim deleted file mode 100644 index aaf65ab..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipmate/jumping.vim +++ /dev/null @@ -1,228 +0,0 @@ -function! s:sfile() abort - return expand('<sfile>') -endfunction - -let s:state_proto = {} - -function! snipmate#jumping#state() abort - return copy(s:state_proto) -endfunction - -function! s:listize_mirror(mirrors) abort - return map(copy(a:mirrors), '[v:val.line, v:val.col]') -endfunction - -" Removes snippet state info -function! s:state_remove() dict abort - " Remove all autocmds in group snipmate_changes in the current buffer - unlet! b:snip_state - silent! au! snipmate_changes * <buffer> -endfunction - -function! s:state_find_next_stop(backwards) dict abort - let self.stop_no += a:backwards? -1 : 1 - while !has_key(self.stops, self.stop_no) - if self.stop_no == self.stop_count - let self.stop_no = 0 - endif - if self.stop_no <= 0 && a:backwards - let self.stop_no = self.stop_count - 1 - endif - let self.stop_no += a:backwards? -1 : 1 - endwhile -endfunction - -" Update state information to correspond to the given tab stop -function! s:state_set_stop(backwards) dict abort - call self.find_next_stop(a:backwards) - let self.cur_stop = self.stops[self.stop_no] - let self.stop_len = (type(self.cur_stop.placeholder) == type(0)) - \ ? self.cur_stop.placeholder - \ : len(snipMate#placeholder_str(self.stop_no, self.stops)) - let self.start_col = self.cur_stop.col - let self.end_col = self.start_col + self.stop_len - let self.mirrors = get(self.cur_stop, 'mirrors', []) - let self.old_mirrors = deepcopy(self.mirrors) - call cursor(self.cur_stop.line, self.cur_stop.col) - let self.prev_len = col('$') - let self.changed = 0 - let ret = self.select_word() - if (self.stop_no == 0 || self.stop_no == self.stop_count - 1) && !a:backwards - call self.remove() - endif - return ret -endfunction - -" Jump to the next/previous tab stop -function! s:state_jump_stop(backwards) dict abort - " Update changes just in case - " This seems to be only needed because insert completion does not trigger - " the CursorMovedI event - call self.update_changes() - - " Store placeholder/location changes - let self.cur_stop.col = self.start_col - if self.changed - call self.remove_nested() - unlet! self.cur_stop.placeholder " avoid type error for old parsing version - let self.cur_stop.placeholder = [strpart(getline('.'), - \ self.start_col - 1, self.end_col - self.start_col)] - endif - - return self.set_stop(a:backwards) -endfunction - -function! s:state_remove_nested(...) dict abort - let id = a:0 ? a:1 : self.stop_no - if type(self.stops[id].placeholder) == type([]) - for i in self.stops[id].placeholder - if type(i) == type([]) - if type(i[1]) != type({}) - call self.remove_nested(i[0]) - call remove(self.stops, i[0]) - else - call filter(self.stops[i[0]].mirrors, 'v:val isnot i[1]') - endif - endif - unlet i " Avoid E706 - endfor - endif -endfunction - -" Select the placeholder for the current tab stop -function! s:state_select_word() dict abort - let len = self.stop_len - if !len | return '' | endif - let l = col('.') != 1 ? 'l' : '' - if &sel == 'exclusive' - return "\<esc>".l.'v'.len."l\<c-g>" - endif - return len == 1 ? "\<esc>".l.'gh' : "\<esc>".l.'v'.(len - 1)."l\<c-g>" -endfunction - -" Update the snippet as text is typed. The self.update_mirrors() function does -" the actual work. -" If the cursor moves outside of a placeholder, call self.remove() -function! s:state_update_changes() dict abort - let change_len = col('$') - self.prev_len - let self.changed = self.changed || change_len != 0 - let self.end_col += change_len - let col = col('.') - - if line('.') != self.cur_stop.line || col < self.start_col || col > self.end_col - return self.remove() - endif - - call self.update(self.cur_stop, change_len, change_len) - if !empty(self.mirrors) - call self.update_mirrors(change_len) - endif - - let self.prev_len = col('$') -endfunction - -" Actually update the mirrors for any changed text -function! s:state_update_mirrors(change) dict abort - let newWordLen = self.end_col - self.start_col - let newWord = strpart(getline('.'), self.start_col - 1, newWordLen) - let changeLen = a:change - let curLine = line('.') - let curCol = col('.') - let oldStartSnip = self.start_col - let i = 0 - - for mirror in self.mirrors - for stop in values(filter(copy(self.stops), 'v:key != 0')) - if type(stop.placeholder) == type(0) - if mirror.line == stop.line && mirror.col > stop.col - \ && mirror.col < stop.col + stop.placeholder - let stop.placeholder += changeLen - endif - endif - endfor - - if has_key(mirror, 'oldSize') - " recover the old size deduce the endline - let oldSize = mirror.oldSize - else - " first time, we use the intitial size - let oldSize = strlen(newWord) - endif - - " Split the line into three parts: the mirror, what's before it, and - " what's after it. Then combine them using the new mirror string. - " Subtract one to go from column index to byte index - - let theline = getline(mirror.line) - - " part before the current mirror - let beginline = strpart(theline, 0, mirror.col - 1) - - " current mirror transformation, and save size - let wordMirror= substitute(newWord, get(mirror, 'pat', ''), get(mirror, 'sub', ''), get(mirror, 'flags', '')) - let mirror.oldSize = strlen(wordMirror) - - " end of the line, use the oldSize because with the transformation, - " the size of the mirror can be different from those of the snippet - let endline = strpart(theline, mirror.col + oldSize -1) - - " Update other object on the line - call self.update(mirror, changeLen, mirror.oldSize - oldSize) - - " reconstruct the line - let update = beginline.wordMirror.endline - - call setline(mirror.line, update) - endfor - - " Reposition the cursor in case a var updates on the same line but before - " the current tabstop - if oldStartSnip != self.start_col || mode() == 'i' - call cursor(0, curCol + self.start_col - oldStartSnip) - endif -endfunction - -function! s:state_find_update_objects(item) dict abort - let item = a:item - let item.update_objects = [] - - " Filter the zeroth stop because it's duplicated as the last - for stop in values(filter(copy(self.stops), 'v:key != 0')) - if stop.line == item.line && stop.col > item.col - call add(item.update_objects, stop) - endif - - for mirror in get(stop, 'mirrors', []) - if mirror.line == item.line && mirror.col > item.col - call add(item.update_objects, mirror) - endif - endfor - endfor - - return item.update_objects -endfunction - -function! s:state_update(item, change_len, mirror_change) dict abort - let item = a:item - if !exists('item.update_objects') - let item.update_objects = self.find_update_objects(a:item) - endif - let to_update = item.update_objects - - for obj in to_update - " object does not necessarly have the same decalage - " than mirrors if mirrors use regexp - let obj.col += a:mirror_change - if obj is self.cur_stop - let self.start_col += a:change_len - let self.end_col += a:change_len - endif - endfor -endfunction - -call extend(s:state_proto, snipmate#util#add_methods(s:sfile(), 'state', - \ [ 'remove', 'set_stop', 'jump_stop', 'remove_nested', - \ 'select_word', 'update_changes', 'update_mirrors', - \ 'find_next_stop', 'find_update_objects', 'update' ]), 'error') - -" vim:noet:sw=4:ts=4:ft=vim diff --git a/vim/bundle/vim-snipmate/autoload/snipmate/legacy.vim b/vim/bundle/vim-snipmate/autoload/snipmate/legacy.vim deleted file mode 100644 index 7ff39cb..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipmate/legacy.vim +++ /dev/null @@ -1,139 +0,0 @@ -let s:sigil = nr2char(31) -let snipmate#legacy#sigil = s:sigil - -" Prepare snippet to be processed by s:BuildTabStops -function! snipmate#legacy#process_snippet(snip) abort - let snippet = a:snip - let esc_bslash = '\%(\\\@<!\%(\\\\\)*\)\@<=' - - if exists('b:snipmate_visual') - let visual = substitute(b:snipmate_visual, "\n$", '', '') - unlet b:snipmate_visual - else - let visual = '' - endif - let snippet = s:substitute_visual(snippet, visual) - - " Evaluate eval (`...`) expressions. - " Backquotes prefixed with a backslash "\" are ignored. - " And backslash can be escaped by doubling it. - " Using a loop here instead of a regex fixes a bug with nested "\=". - if stridx(snippet, '`') != -1 - let new = [] - let snip = split(snippet, esc_bslash . '`', 1) - let isexp = 0 - for i in snip - if isexp - call add(new, substitute(snipmate#util#eval(i), - \ "\n\\%$", '', '')) - else - call add(new, i) - endif - let isexp = !isexp - endfor - let snippet = join(new, '') - let snippet = substitute(snippet, "\r", "\n", 'g') - let snippet = substitute(snippet, '\\`', "`", 'g') - endif - - " Place all text after a colon in a tab stop after the tab stop - " (e.g. "${#:foo}" becomes "${:foo}foo"). - " This helps tell the position of the tab stops later. - let snippet = substitute(snippet, esc_bslash . '\$\({\d\+:\(.\{-}\)}\|{\d\+}\)', s:sigil . '\1\2', 'g') - let snippet = substitute(snippet, esc_bslash . '\$\(\d\+\)', s:sigil . '\1', 'g') - let snippet = substitute(snippet, esc_bslash . '\\\$', '$', 'g') - let snippet = substitute(snippet, '\\\\', "\\", 'g') - - " Update the a:snip so that all the $# become the text after - " the colon in their associated ${#}. - " (e.g. "${1:foo}" turns all "$1"'s into "foo") - let i = 0 - if snippet !~ s:sigil . '{0' - let snippet .= s:sigil . '{0}' - endif - while snippet =~ s:sigil.'{'.i - let s = matchstr(snippet, s:sigil . '{' . i . ':\zs.\{-}\ze}') - if s != '' - let snippet = substitute(snippet, s:sigil . i, s.'&', 'g') - endif - let i += 1 - endw - - if &et " Expand tabs to spaces if 'expandtab' is set. - return substitute(snippet, '\t', repeat(' ', snipmate#util#tabwidth()), 'g') - endif - return snippet -endfunction - -" Builds a list of a list of each tab stop in the snippet containing: -" 1.) The tab stop's line number. -" 2.) The tab stop's column number -" (by getting the length of the string between the last "\n" and the -" tab stop). -" 3.) The length of the text after the colon for the current tab stop -" (e.g. "${1:foo}" would return 3). -" 4.) If the "${#:}" construct is given, another list containing all -" the matches of "$#", to be replaced with the placeholder. This list is -" composed the same way as the parent; the first item is the line number, -" and the second is the column. -function! snipmate#legacy#build_stops(snip, lnum, col, indent) abort - let stops = {} - let i = 0 - let withoutVars = substitute(a:snip, s:sigil . '\d\+', '', 'g') - while a:snip =~ s:sigil . '{' . i - let beforeTabStop = matchstr(withoutVars, '^.*\ze'.s:sigil .'{'.i.'\D') - let withoutOthers = substitute(withoutVars, ''.s:sigil .'{\('.i.'\D\)\@!\d\+.\{-}}', '', 'g') - - let stops[i] = {} - let stops[i].line = a:lnum + s:count(beforeTabStop, "\n") - let stops[i].col = a:indent + len(matchstr(withoutOthers, '[^\n]\{-}\ze'.s:sigil .'{'.i.'\D')) - let stops[i].placeholder = 0 - let stops[i].mirrors = [] - if stops[i].line == a:lnum - let stops[i].col += a:col - endif - - " Get all $# matches in another list, if ${#:name} is given - if withoutVars =~ printf('%s{%d:', s:sigil, i) - let stops[i].placeholder = len(matchstr(withoutVars, ''.s:sigil .'{'.i.':\zs.\{-}\ze}')) - let withoutOthers = substitute(a:snip, ''.s:sigil .'{\d\+.\{-}}\|'.s:sigil .''.i.'\@!\d\+', '', 'g') - - while match(withoutOthers, ''.s:sigil .''.i.'\(\D\|$\)') != -1 - let stops[i].mirrors = get(stops[i], 'mirrors', []) - let beforeMark = matchstr(withoutOthers, - \ printf('^.\{-}\ze%s%s%d\(\D\|$\)', - \ repeat('.', stops[i].placeholder), s:sigil, i)) - let line = a:lnum + s:count(beforeMark, "\n") - let col = a:indent + (line > a:lnum - \ ? len(matchstr(beforeMark, '.*\n\zs.*')) - \ : a:col + len(beforeMark)) - call add(stops[i].mirrors, { 'line' : line, 'col' : col }) - let withoutOthers = substitute(withoutOthers, ''.s:sigil .''.i.'\ze\(\D\|$\)', '', '') - endw - endif - let i += 1 - endw - let stops[i] = stops[0] - return [stops, i + 1] -endfunction - -function! s:substitute_visual(snippet, visual) abort - let lines = [] - for line in split(a:snippet, "\n") - let indent = matchstr(line, '^\t\+') - call add(lines, substitute(line, '{VISUAL}', - \ substitute(escape(a:visual, '%\'), "\n", "\n" . indent, 'g'), 'g')) - endfor - return join(lines, "\n") -endfunction - -" Counts occurences of haystack in needle -function! s:count(haystack, needle) abort - let counter = 0 - let index = stridx(a:haystack, a:needle) - while index != -1 - let index = stridx(a:haystack, a:needle, index+1) - let counter += 1 - endw - return counter -endfunction diff --git a/vim/bundle/vim-snipmate/autoload/snipmate/parse.vim b/vim/bundle/vim-snipmate/autoload/snipmate/parse.vim deleted file mode 100644 index dd495e9..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipmate/parse.vim +++ /dev/null @@ -1,309 +0,0 @@ -" Snippet definition parsing code - -function! s:sfile() abort - return expand('<sfile>') -endfunction - -let s:parser_proto = {} -let s:special_chars = "$`\n" - -function! s:new_parser(text) abort - let ret = copy(s:parser_proto) - let ret.input = a:text - let ret.len = strlen(ret.input) - let ret.pos = -1 - let ret.indent = 0 - let ret.value = [] - let ret.vars = {} - let ret.stored_lines = [] - call ret.advance() - return ret -endfunction - -function! s:parser_advance(...) dict abort - let self.pos += a:0 ? a:1 : 1 - let self.next = self.input[self.pos] -endfunction - -function! s:parser_same(tok) dict abort - if self.next == a:tok - call self.advance() - return 1 - else - return 0 - endif -endfunction - -function! s:parser_id() dict abort - if self.input[(self.pos):(self.pos+5)] == 'VISUAL' - call self.advance(6) - return 'VISUAL' - elseif self.next =~ '\d' - let end = matchend(self.input, '\d\+', self.pos) - let res = strpart(self.input, self.pos, end - self.pos) - call self.advance(end - self.pos) - return +res " force conversion to Number - endif - return -1 -endfunction - -function! s:parser_add_var(var) dict abort - let id = a:var[0] - if !has_key(self.vars, id) - let self.vars[id] = { 'instances' : [] } - endif - call add(self.vars[id].instances, a:var) -endfunction - -function! s:parser_var() dict abort - let ret = [] - if self.same('{') - let id = self.id() - if id >= 0 - call add(ret, id) - call extend(ret, self.varend()) - endif - else - let id = self.id() - if id >= 0 - call add(ret, id) - endif - endif - return ret -endfunction - -function! s:parser_varend() dict abort - let ret = [] - if self.same(':') - call extend(ret, self.placeholder()) - elseif self.same('/') - call add(ret, self.subst()) - endif - call self.same('}') - return ret -endfunction - -function! s:parser_placeholder() dict abort - let ret = self.text('}') - return empty(ret) ? [''] : ret -endfunction - -function! s:parser_subst() dict abort - let ret = {} - let ret.pat = self.pat() - if self.same('/') - let ret.sub = self.pat(1) - endif - if self.same('/') - let ret.flags = self.pat(1) - endif - return ret -endfunction - -function! s:parser_pat(...) dict abort - let val = '' - - while self.pos < self.len - if self.same('\') - if self.next == '/' - let val .= '/' - call self.advance() - elseif a:0 && self.next == '}' - let val .= '}' - call self.advance() - else - let val .= '\' - endif - elseif self.next == '/' || a:0 && self.next == '}' - break - else - let val .= self.next - call self.advance() - endif - endwhile - - return val -endfunction - -function! s:parser_expr() dict abort - let str = self.string('`') - call self.same('`') - return snipmate#util#eval(str) -endfunction - -function! s:parser_string(till, ...) dict abort - let val = '' - let till = '\V\[' . escape(a:till, '\') . ']' - - while self.pos < self.len - if self.same('\') - if self.next != "\n" - let val .= self.next - endif - call self.advance() - elseif self.next =~# till - break - elseif self.next == "\t" - let self.indent += 1 - let val .= s:indent(1) - call self.advance() - else - let val .= self.next - call self.advance() - endif - endwhile - - return val -endfunction - -function! s:join_consecutive_strings(list) abort - let list = a:list - let pos = 0 - while pos + 1 < len(list) - if type(list[pos]) == type('') && type(list[pos+1]) == type('') - let list[pos] .= list[pos+1] - call remove(list, pos + 1) - else - let pos += 1 - endif - endwhile -endfunction - -function! s:parser_text(till) dict abort - let ret = [] - - while self.pos < self.len - let lines = [] - - if self.same('$') - let var = self.var() - if !empty(var) - if var[0] is# 'VISUAL' - let lines = s:visual_placeholder(var, self.indent) - elseif var[0] >= 0 - call add(ret, var) - call self.add_var(var) - endif - endif - elseif self.same('`') - let lines = split(self.expr(), "\n", 1) - else - let lines = [self.string(a:till . s:special_chars)] - endif - - if !empty(lines) - call add(ret, lines[0]) - call extend(self.stored_lines, lines[1:]) - endif - - " Empty lines are ignored if this is tested at the start of an iteration - if self.next ==# a:till - break - endif - endwhile - - call s:join_consecutive_strings(ret) - return ret -endfunction - -function! s:parser_line() dict abort - let ret = [] - if !empty(self.stored_lines) - call add(ret, remove(self.stored_lines, 0)) - else - call extend(ret, self.text("\n")) - call self.same("\n") - endif - let self.indent = 0 - return ret -endfunction - -function! s:parser_parse() dict abort - while self.pos < self.len || !empty(self.stored_lines) - let line = self.line() - call add(self.value, line) - endwhile -endfunction - -function! s:indent(count) abort - if &expandtab - let shift = repeat(' ', snipmate#util#tabwidth()) - else - let shift = "\t" - endif - return repeat(shift, a:count) -endfunction - -function! s:visual_placeholder(var, indent) abort - let arg = get(a:var, 1, {}) - if type(arg) == type({}) - let pat = get(arg, 'pat', '') - let sub = get(arg, 'sub', '') - let flags = get(arg, 'flags', '') - let content = split(substitute(get(b:, 'snipmate_visual', ''), pat, sub, flags), "\n", 1) - else - let content = split(get(b:, 'snipmate_visual', arg), "\n", 1) - endif - - let indent = s:indent(a:indent) - call map(content, '(v:key != 0) ? indent . v:val : v:val') - - return content -endfunction - -function! s:parser_create_stubs() dict abort - - for [id, dict] in items(self.vars) - for i in dict.instances - if len(i) > 1 && type(i[1]) != type({}) - if !has_key(dict, 'placeholder') - let dict.placeholder = i[1:] - call add(i, dict) - else - unlet i[1:] - call s:create_mirror_stub(i, dict) - endif - else - call s:create_mirror_stub(i, dict) - endif - endfor - if !has_key(dict, 'placeholder') - let dict.placeholder = [] - let j = 0 - while len(dict.instances[j]) > 2 - let j += 1 - endwhile - let oldstub = remove(dict.instances[j], 1, -1)[-1] - call add(dict.instances[j], '') - call add(dict.instances[j], dict) - call filter(dict.mirrors, 'v:val isnot oldstub') - endif - unlet dict.instances - endfor - -endfunction - -function! s:create_mirror_stub(mirror, dict) - let mirror = a:mirror - let dict = a:dict - let stub = get(mirror, 1, {}) - call add(mirror, stub) - let dict.mirrors = get(dict, 'mirrors', []) - call add(dict.mirrors, stub) -endfunction - -function! snipmate#parse#snippet(text, ...) abort - let parser = s:new_parser(a:text) - call parser.parse() - if !(a:0 && a:1) - call parser.create_stubs() - endif - unlet! b:snipmate_visual - return [parser.value, parser.vars] -endfunction - -call extend(s:parser_proto, snipmate#util#add_methods(s:sfile(), 'parser', - \ [ 'advance', 'same', 'id', 'add_var', 'var', 'varend', - \ 'line', 'string', 'create_stubs', 'pat', - \ 'placeholder', 'subst', 'expr', 'text', 'parse', - \ ]), 'error') diff --git a/vim/bundle/vim-snipmate/autoload/snipmate/util.vim b/vim/bundle/vim-snipmate/autoload/snipmate/util.vim deleted file mode 100644 index a80d307..0000000 --- a/vim/bundle/vim-snipmate/autoload/snipmate/util.vim +++ /dev/null @@ -1,30 +0,0 @@ -" The next function was based on s:function and s:add_methods in fugitive -" <https://github.com/tpope/vim-fugitive/blob/master/plugin/fugitive.vim> -function! snipmate#util#add_methods(sfile, namespace, methods) abort - let dict = {} - for name in a:methods - let dict[name] = function(join([matchstr(a:sfile, '<SNR>\d\+'), - \ a:namespace, name], '_')) - endfor - return dict -endfunction - -function! snipmate#util#eval(arg) - try - let ret = eval(a:arg) - catch - echohl ErrorMsg - echom 'SnipMate:Expression: ' . v:exception - echohl None - let ret = '' - endtry - return type(ret) == type('') ? ret : string(ret) -endfunction - -function! snipmate#util#tabwidth() - if &sts > 0 - return &sts - else - return exists('*shiftwidth') ? shiftwidth() : &sw - endif -endfunction diff --git a/vim/bundle/vim-snipmate/doc/SnipMate.txt b/vim/bundle/vim-snipmate/doc/SnipMate.txt deleted file mode 100644 index 230fe68..0000000 --- a/vim/bundle/vim-snipmate/doc/SnipMate.txt +++ /dev/null @@ -1,646 +0,0 @@ -*SnipMate.txt* Plugin for using TextMate-style snippets in Vim. - -SnipMate *snippet* *snippets* *SnipMate* - -1. Description |SnipMate-description| -2. Usage |SnipMate-usage| -3. Interface and Settings |SnipMate-interface| |SnipMate-settings| -4. Snippets |SnipMate-snippets| - - Snippet files |SnipMate-snippet-files| - - Snippet syntax |SnipMate-syntax| -5. Snippet sources |SnipMate-snippet-sources| -6. Disadvantages to TextMate |SnipMate-disadvantages| -7. Contact |SnipMate-contact| -8. License |SnipMate-license| - -For Vim version 7.0 or later. -This plugin only works if 'compatible' is not set. -{Vi does not have any of these features.} - -SnipMate depends on vim-addon-mw-utils and tlib. - -============================================================================== -DESCRIPTION *SnipMate-description* - -SnipMate implements snippet features in Vim. A snippet is like a template, -reducing repetitive insertion of pieces of text. Snippets can contain -placeholders for modifying the text if necessary or interpolated code for -evaluation. For example, in C, typing "for" then pushing <Tab> could expand -to: > - - for (i = 0; i < count; i++) { - /* code */ - } - -SnipMate is inspired by TextMate's snippet features. - -============================================================================== -USAGE *SnipMate-usage* - -Every snippet consists of an expansion and a trigger. Typing a trigger into -your buffer and then hitting your trigger key (<Tab> by default, see -|SnipMate-mappings|) will replace the trigger with the expansion text. - -The expansion text can optionally include tab stops. When it does, upon -expansion of the snippet, the cursor is placed at the first one, and the user -can jump between each tab stop. Each of these tab stops can be represented by -default placeholder text. If such a placeholder is provided, then the text of -the placeholder can be repeated in the snippet at specified mirrors. Any edits -to the placeholder are instantly updated at every mirror. - -SnipMate allows multiple snippets to use the same trigger. When triggered, -a list of all snippets with that trigger is provided and prompts for which -snippet to use. - - *SnipMate-scopes* -SnipMate searches for snippets inside a directory named "snippets" inside each -entry in 'runtimepath'. Which files are loaded depends on 'filetype' and -'syntax'; see |SnipMate-syntax| for more information. Snippets are loaded and -refreshed automatically on demand. - -Note: SnipMate does not ship with any snippets. In order to use it, the user -must either write their own snippets or obtain some from a repository like -https://github.com/honza/vim-snippets - -============================================================================== -INTERFACE AND SETTINGS *SnipMate-interface* *SnipMate-settings* - - *SnipMate-commands* -Commands~ - - *:SnipMateOpenSnippetFiles* -:SnipMateOpenSnippetFiles Opens a list of all valid snippet locations - based on the current scope |SnipMate-scopes|. - Only existing files and non-existing .snippets - files will be shown, with the existing files - shown first. - -:SnipMateLoadScope[!] scope [scope ...] - Load snippets from additional scopes. Without - [!] the additional scopes are loaded only in - the current buffer. For example > - :SnipMateLoadScopes rails -< will load all rails.snippets in the current - buffer. - - *SnipMate-options* -Options~ - -g:snips_author A variable used in some snippets in place of - the author's (your) name. Similar to - $TM_FULLNAME in TextMate. For example, > - snippet name - `g:snips_author` -< creates a snippet "name" that expands to your - name. - -g:snipMate This |Dictionary| contains other SnipMate - options. In short add > - let g:snipMate = {} -< to your .vimrc before setting other SnipMate - options. - -g:snipMate.scope_aliases A |Dictionary| associating certain filetypes - with other scopes |SnipMate-scopes|. The - entries consist of a filetype as the key and - a comma-separated list of aliases as the - value. For example, > - let g:snipMate.scope_aliases = {} - let g:snipMate.scope_aliases['ruby'] - \ = 'ruby,ruby-rails' -< tells SnipMate that "ruby-rails" snippets in - addition to "ruby" snippets should be loaded - when editing files with 'filetype' set to - "ruby" or contains "ruby" as an entry in the - case of dotted filetypes. A buffer local - variant b:snipMate_scope_aliases is merged - with the global variant. - -g:snipMate_no_default_aliases Note: This has been renamed to the following. - -g:snipMate.no_default_aliases - When set to 1, prevents SnipMate from loading - default scope aliases. The defaults are: - Filetype Alias ~ - cpp c - cu c - eruby eruby-rails,html - html javascript - mxml actionscript - objc c - php php,html,javascript - ur html,javascript - xhtml html - Individual defaults can be disabled by setting - them to an empty value: > - let g:snipMate.scope_aliases.php = '' -< will disable the default PHP alias. - Note: Setting this option does not disable - scope aliases entirely, only those made by - SnipMate itself. Any scope aliases created by - the user or someone else will still be in - effect. - -g:snipMate.snippet_version - The snippet parser version to use. The - possible values are: - 0 Use the older parser - 1 Use the newer parser - If unset, SnipMate defaults to version 0. The - value of this option is also used for all - .snippet files. - -g:snipMate.override - As detailed below, when two snippets with the - same name and description are loaded, both are - kept and differentiated by the location of the - file they were in. When this option is enabled - (set to 1), the snippet originating in the - last loaded file is kept, similar to how Vim - maps and other settings work. Note: Load order - is determined by 'runtimepath'. - -g:snipMate['no_match_completion_feedkeys_chars'] - A string inserted when no match for a trigger - is found. By default a tab is inserted - according to 'expandtab', 'tabstop', and - 'softtabstop'. Set it to the empty string to - prevent anything from being inserted. - - *SnipMate-mappings* -Mappings~ - -The mappings SnipMate uses can be customized with the |:map| commands. For -example, to change the key that triggers snippets and moves to the next -tab stop, > - - :imap <C-J> <Plug>snipMateNextOrTrigger - :smap <C-J> <Plug>snipMateNextOrTrigger - -Note: The noremap variants of the map commands must NOT be used. - -The list of possible <Plug> mappings is as follows: - -<Plug>snipMateNextOrTrigger Default: <Tab> Mode: Insert, Select - Jumps to the next tab stop or, if none exists, - try to expand a snippet. Use in both insert - and select modes. - -<Plug>snipMateTrigger Default: unmapped Mode: Insert - Try to expand a snippet regardless of any - existing snippet expansion. If done within an - expanded snippet, the outer snippet's tab - stops are lost, unless expansion failed. - -<Plug>snipMateBack Default: <S-Tab> Mode: Insert, Select - Jump to the previous tab stop, if it exists. - Use in both insert and select modes. - -<Plug>snipMateShow Default: <C-R><Tab> Mode: Insert - Show all available snippets (that start with - the previous text, if it exists). Use in - insert mode. - -<Plug>snipMateVisual Default: <Tab> Mode: Visual - See |SnipMate-visual|. - -Additionally, <CR> is mapped in visual mode in .snippets files for retabbing -snippets. - -============================================================================== -SNIPPETS *SnipMate-snippets* - - *SnipMate-snippet-files* -Snippet Files ~ - -Note: SnipMate does not ship with any snippets. - -SnipMate looks inside of each entry of 'rtp' (or |SnipMate-snippet-sources|) -for a directory named /snippets/. Based on the 'filetype' and 'syntax' -settings (dotted filetypes are parsed), the following files are read for -snippets: > - - .../snippets/<scope>.snippets - .../snippets/<scope>_<name>.snippets - .../snippets/<scope>/<name>.snippets - .../snippets/<scope>/<trigger>.snippet - .../snippets/<scope>/<trigger>/<description>.snippet - -where <scope> is a scope or 'filetype' or 'syntax', <name> is an arbitrary -name, <trigger> is the trigger for a snippet, and <description> is -a description used for |SnipMate-multisnip|. - -A .snippet file defines a single snippet with the trigger (and description) -determined by the filename. The entire contents of the file are used as the -snippet expansion text. - -Multiple snippets can be defined in *.snippets files. Each snippet definition -looks something like: > - - snippet trigger optional description - expanded text - more expanded text - -< *SnipMate-multisnip* -The description is optional. If it is left out, the description "default" is -used. When two snippets in the same scope have the same name and the same -description, SnipMate will try to preserve both. The g:snipMate.override -option disables this, in favor of keeping the last-loaded snippet. This can be -overridden on a per-snippet basis by defining the snippet with a bang (!): > - - snippet! trigger optional description - expanded text - more expanded text - -Two bangs will remove the trigger entirely from SnipMate's lookup. In this -case any snippet text is unused. - -Note: Hard tabs in the expansion text are required. When the snippet is -expanded in the text and 'expandtab' is set, each tab will be replaced with -spaces based on 'softtabstop' if nonzero or 'shiftwidth' otherwise. - -Which version parser the snippets in a file should be used with can be -specified with a version line, e.g.: > - - version 1 - -Specification of a version applies to the snippets following it. Multiple -version specifications can appear in a single file to intermix version 0 and -version 1 snippets. - -Comments can be made in .snippets files by starting a line with a # character. -However these can't be used inside of snippet definitions: > - - # this is a correct comment - snippet trigger - expanded text - snippet another_trigger - # this isn't a comment! - expanded text - -This should hopefully be clear with the included syntax highlighting. - - *snipMate-extends* -Borrowing from UltiSnips, .snippets files can also contain an extends -directive, for example: > - - extends html, javascript, css - -will tell SnipMate to also read html, javascript, and css snippets. - -SNIPPET SYNTAX *snippet-syntax* *SnipMate-syntax* - -Anywhere in a snippet, a backslash escapes the character following it, -regardless of whether that character is special or not. That is, '\a' will -always result in an 'a' in the output. A single backslash can be output by -using '\\'. - - *SnipMate-tabstops* -Tab stops~ - -When triggering a snippet, SnipMate will by default jump to the very end of -the snippet text. This can be changed through the use of tab stops: $1, $2, -and so on. After expansion, SnipMate will jump to the first tab stop. From -then on, the <Plug>snipMateNextOrTrigger map will jump to the next higher -numbered tabs top. - -In the case of an ambiguity, for example if a stop occurs just before -a literal number, braces may be placed around the stop number to resolve it: -${3}79 is the third tab stop followed by the string "79". - -NOTE: In the version 0 snippet parser, the braces are mandatory. - - *SnipMate-zero-tabstop* -SnipMate will always stop at the special zero tab stop $0. Once it jumps to -the zero tab stop, snippet expansion is finished. If the zero tab stop is not -present in a definition, it will be put at the end. - -For example, to place the cursor first on the id of a <div> tag, then on its -class, and finally end editing its contents: > - - snippet div - <div id="$1" class="$2"> - $0 - </div> - -< *SnipMate-placeholders* -In addition to being simply a location, each tab stop contains a placeholder, -or some default text. The placeholder can be specified for every tab stop -(including the zero tab stop) with a colon after the stop ID, as in -${1:default text}. The braces are required only when specifying a placeholder. -Once a tab stop with a placeholder is reached, the placeholder will be -selected in |Select-mode|. For example, > - - snippet div - <div id="${1:id}" class="${2:class}"> - $0 - </div> - -Finally, placeholders can contain mirrors and evaluations (detailed below) and -even entire other tab stops. If the placeholder is edited, then these nested -tab stops are removed and skipped entirely. For example, > - - snippet div - <div${1: id="${2:id}"}${3: class="${4:class}"}> - $0 - </div> - -When expanded, this snippet selects the entirety of the id attribute. If this -stop is edited, then the second tab stop is removed and the third tab stop -becomes the next one. If the first tab stop is left unedited, then SnipMate -jumps to the second tab stop. This allows the user to use a single div snippet -that can be used for instances where the id or class attributes are desired -and those where they are not. - - *SnipMate-mirrors* -Mirrors~ - -A mirror is simply a copy of a tab stop's text, updated as the tab stop is -edited. These look like a tab stop without a placeholder; $1 for example. In -the event that no placeholder is specified for a certain tab stop--say $1--the -first instance becomes the tab stop and the rest become mirrors. - -Additionally substitutions similar to |:substitute| can be performed. For -instance ${1/foo/bar/g} will replace all instances of "foo" in the $1 mirror -with "bar". This uses |substitute()| behind the scenes. - -Note: Just like with tab stops, braces can be used to avoid ambiguities: ${1}2 -is a mirror of the first tab stop followed by a 2. Version 0 of the snippet -parser offers no way to resolve such ambiguities. - -As an example, > - - snippet for - for ($1 = ${2:start}; ${1:i} < ${3:end}; $1${4:++}) { - ${0:/* code */} - } - -< *SnipMate-eval* -Expression Evaluation~ - -Snippets can contain Vim script expressions that are evaluated as the snippet -is expanded. Expressions are specified inside backticks: > - - snippet date - `strftime("%Y-%m-%d")` - -If the expression results in any Vim error, the error will be displayed (or -found in :messages) and the result of the expression will be the empty string. - -Filename([{expr}] [, {defaultText}]) *SnipMate-Filename()* - -Since the current filename is used often in snippets, a default function -has been defined for it in SnipMate.vim, appropriately called Filename(). - -With no arguments, the default filename without an extension is returned; -the first argument specifies what to place before or after the filename, -and the second argument supplies the default text to be used if the file -has not been named. "$1" in the first argument is replaced with the filename; -if you only want the filename to be returned, the first argument can be left -blank. Examples: > - - snippet filename - `Filename()` - snippet filename_with_default - `Filename('', 'name')` - snippet filename_foo - `Filename('$1_foo')` - -The first example returns the filename if it the file has been named, and an -empty string if it hasn't. The second returns the filename if it's been named, -and "name" if it hasn't. The third returns the filename followed by "_foo" if -it has been named, and an empty string if it hasn't. - - *SnipMate-visual* -The VISUAL Stop~ - -While tab stops have numeric IDs, a special one exists with the ID 'VISUAL'. -When a snippet is expanded, if any text had been grabbed with the -snipMateVisual mapping (see |SnipMate-mappings|), all instances of the VISUAL -stop will be replaced with it. Both transformations as well as a default -placeholder can be used with the VISUAL stop. - -Note: Both $VISUAL and ${VISUAL} are valid in version 1 of the snippet parser. -In version 0, only {VISUAL} is valid (without the $), and neither -transformations nor a default placeholder can be used. - -Example: > - - snippet div - <div> - ${0:${VISUAL:<!-- content -->}} - </div> - -============================================================================== -SNIPPET SOURCES *SnipMate-snippet-sources* - -SnipMate is configurable. - -plugin/SnipMate.vim assigns a couple important keys: > - - " default implementation collecting snippets by handlers - let g:SnipMate['get_snippets'] = SnipMate#GetSnippets - " default handler: - let g:SnipMateSources['default'] = SnipMate#DefaultPool - -You can override both of those settings. - -You can see that the default set of snippets is determined by Vim's 'rtp'. - -Example 1:~ -autoload/SnipMate_python_demo.vim shows how you can register additional -sources such as creating snippets on the fly representing python function -definitions found in the current file. - -Example 2:~ -Add to your ~/.vimrc: For each know snippet add a second version ending in _ -adding folding markers > - - let g:commentChar = { - \ 'vim': '"', - \ 'c': '//', - \ 'cpp': '//', - \ 'sh': '#', - \ 'python': '#' - \ } - " url https://github.com/garbas/vim-snipmate/issues/49 - fun! AddFolding(text) - return substitute(a:text,'\n'," ".g:commentChar[&ft]." {{{\n",1)."\n".g:commentChar[&ft]." }}}" - endf - - fun! SnippetsWithFolding(scopes, trigger, result) - " hacky: temporarely remove this function to prevent infinite recursion: - call remove(g:SnipMateSources, 'with_folding') - " get list of snippets: - let result = SnipMate#GetSnippets(a:scopes, substitute(a:trigger,'_\(\*\)\?$','\1','')) - let g:SnipMateSources['with_folding'] = funcref#Function('SnippetsWithFolding') - - " add folding: - for k in keys(result) - let a:result[k.'_'] = map(result[k],'AddFolding(v:val)') - endfor - endf - - " force setting default: - runtime plugin/SnipMate.vim - " add our own source - let g:SnipMateSources['with_folding'] = funcref#Function('SnippetsWithFolding') - -See |SnipMate-syntax| for more details about all possible relative locations -to 'rtp' can be found in. - -============================================================================== -KNOWN ISSUES *SnipMate-known-issues* - -SnipMate.vim currently has the following disadvantages to TextMate's snippets: - - Placeholders cannot span multiple lines. - - Activating snippets in different scopes of the same file is - not possible. - - Vim formatting with fo=t or fo=a can mess up SnipMate. - -Perhaps some of these features will be added in a later release. - -============================================================================== -CHANGELOG *SnipMate-changelog* - -0.89 - 2016-05-29 ------------------ - -* Various regex updates to legacy parser Addition of double bang syntax to -* completely remove a snippet from lookup Group various SnipMate autocommands -* Support setting 'shiftwidth' to 0 Parser now operates linewise, adding some -* flexibility Mirror substitutions are more literal Mirror length is -* calculated correctly when substitutions occur - -0.88 - 2015-04-04 ------------------ - -* Implement simple caching -* Remove expansion guards -* Add `:SnipMateLoadScope` command and buffer-local scope aliases -* Load `<scope>_*.snippets` files -* Use CursorMoved autocmd events entirely - -* The nested branch has been merged - * A new snippet parser has been added. The g:snipmate.version as well as - version lines in snippet files determines which is used - * The new parser supports tab stops placed within placeholders, - substitutions, non-consecutive stop numbers, and fewer ambiguities - * The stop jumping code has been updated - * Tests have been added for the jumping code and the new parser - -* The override branch has been merged - * The g:snipMate.override option is added. When enabled, if two snippets - share the same name, the later-loaded one is kept and the other discarded - * Override behavior can be enabled on a per-snippet basis with a bang (!) in - the snippet file - * Otherwise, SnipMate tries to preserve all snippets loaded - -* Fix bug with mirrors in the first column -* Fix bug with tabs in indents - <http://github.com/garbas/vim-snipmate/issues/143> -* Fix bug with mirrors in placeholders -* Fix reading single snippet files -* Fix the use of the visual map at the end of a line -* Fix expansion of stops containing only the zero tab stop -* Remove select mode mappings -* Indent visual placeholder expansions and remove extraneous lines - <http://github.com/garbas/vim-snipmate/issues/177> - <http://github.com/garbas/vim-snipmate/issues/178> - -0.87 - 2014-01-04 ------------------ - -* Stop indenting empty lines when expanding snippets -* Support extends keyword in .snippets files -* Fix visual placeholder support -* Add zero tabstop support -* Support negative 'softtabstop' -* Add g:snipMate_no_default_aliases option -* Add <Plug>snipMateTrigger for triggering an expansion inside a snippet -* Add snipMate#CanBeTriggered() function - -0.86 - 2013-06-15 ------------------ -* Use more idiomatic <Plug> maps -* Remove most select mode mappings - -* Fix disappearing variables bug (hpesoj) -* Fix cursor position bug when a variable is on the same line as the stop -* Fix undo point creation causing problems with Supertab -* Fix bug where SnipMate would use a typed trigger as a regular expression - -0.85 - 2013-04-03 ------------------ - -* Allow trigger key customization -* Enable undoing of snippet expansion -* Support backslash escaping in snippets -* Add support for {VISUAL} -* Expand filetype extension with scope_aliases -* Add expansion guards -* Enable per-buffer expansion of snippets -* Fix 'cpo' compatibility -* Update supertab compatibility -* Enable customization of various things through g:SnipMate - -* Disable spelling in snippet files -* Highlight trigger names in .snippets files - -* Update many snippets -* Separate sample snippets into separate repository - -0.84 ----- - -* Unreleased version by Michael Sanders, available on his GitHub, - <https://github.com/msanders/snipmate.vim> - -0.83 - 2009-07-13 ------------------ - -* Last release done by Michael Sanders, available at - <http://www.vim.org/scripts/script.php?script_id=2540> - -============================================================================== -CONTACT *SnipMate-contact* *SnipMate-author* - -SnipMate is currently maintained by: - - Rok Garbas - - Marc Weber (marco-oweber@gmx.de) - - Adnan Zafar - -For bug reports, issues, or questions, check out the Issues page on GitHub: -https://github.com/garbas/vim-snipmate/issues - -The original author, Michael Sanders, can be reached at: -msanders42+snipmate <at> gmail <dot> com - - -============================================================================== -LICENSE *SnipMate-license* - -SnipMate is released under the MIT license: - -Copyright 2009-2010 Michael Sanders. All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -The software is provided "as is", without warranty of any kind, express or -implied, including but not limited to the warranties of merchantability, -fitness for a particular purpose and noninfringement. In no event shall the -authors or copyright holders be liable for any claim, damages or other -liability, whether in an action of contract, tort or otherwise, arising from, -out of or in connection with the software or the use or other dealings in the -software. - -============================================================================== - vim:tw=78:ts=8:ft=help:norl: diff --git a/vim/bundle/vim-snipmate/ftplugin/html_snip_helper.vim b/vim/bundle/vim-snipmate/ftplugin/html_snip_helper.vim deleted file mode 100644 index 4d52392..0000000 --- a/vim/bundle/vim-snipmate/ftplugin/html_snip_helper.vim +++ /dev/null @@ -1,10 +0,0 @@ -" Helper function for (x)html snippets -if exists('s:did_snip_helper') || &cp || !exists('loaded_snips') - finish -endif -let s:did_snip_helper = 1 - -" Automatically closes tag if in xhtml -fun! Close() abort - return stridx(&ft, 'xhtml') == -1 ? '' : ' /' -endf diff --git a/vim/bundle/vim-snipmate/ftplugin/snippets.vim b/vim/bundle/vim-snipmate/ftplugin/snippets.vim deleted file mode 100644 index dde00e4..0000000 --- a/vim/bundle/vim-snipmate/ftplugin/snippets.vim +++ /dev/null @@ -1,20 +0,0 @@ -" Vim filetype plugin for SnipMate snippets (.snippets and .snippet files) - -if exists("b:did_ftplugin") - finish -endif -let b:did_ftplugin = 1 - -let b:undo_ftplugin = "setl et< sts< cms< fdm< fde<" - -" Use hard tabs -setlocal noexpandtab softtabstop=0 - -setlocal foldmethod=expr foldexpr=getline(v:lnum)!~'^\\t\\\\|^$'?'>1':1 - -setlocal commentstring=#\ %s -setlocal nospell - -command! -buffer -range=% RetabSnip - \ echom "This command is deprecated. Use :retab and = instead. Doing that now." - \ | <line1>,<line2>retab! | <line1>,<line2>normal = diff --git a/vim/bundle/vim-snipmate/indent/snippets.vim b/vim/bundle/vim-snipmate/indent/snippets.vim deleted file mode 100644 index 0d28f32..0000000 --- a/vim/bundle/vim-snipmate/indent/snippets.vim +++ /dev/null @@ -1,32 +0,0 @@ -" Simple indent support for SnipMate snippets files - -if exists('b:did_indent') - finish -endif -let b:did_indent = 1 - -setlocal nosmartindent -setlocal indentkeys=!^F,o,O,=snippet,=version,=extends -setlocal indentexpr=GetSnippetIndent() - -if exists("*GetSnippetIndent") - finish -endif - -function! GetSnippetIndent() - let line = getline(v:lnum) - let prev_lnum = v:lnum - 1 - let prev_line = prev_lnum != 0 ? getline(prev_lnum) : "" - - if line =~# '\v^(snippet|extends|version) ' - return 0 - elseif indent(v:lnum) > 0 - return indent(v:lnum) - elseif prev_line =~# '^snippet ' - return &sw - elseif indent(prev_lnum) > 0 - return indent(prev_lnum) - endif - - return 0 -endfunction diff --git a/vim/bundle/vim-snipmate/plugin/snipMate.vim b/vim/bundle/vim-snipmate/plugin/snipMate.vim deleted file mode 100644 index 837f0dc..0000000 --- a/vim/bundle/vim-snipmate/plugin/snipMate.vim +++ /dev/null @@ -1,137 +0,0 @@ -" File: snipMate.vim -" Description: snipMate.vim implements some of TextMate's snippets features in -" Vim. A snippet is a piece of often-typed text that you can -" insert into your document using a trigger word followed by a "<tab>". -" -" For more help see snipMate.txt; you can do this by using: -" :helptags ~/.vim/doc -" :h SnipMate - -if exists('loaded_snips') || &cp || version < 700 - finish -endif -let loaded_snips = 1 - -" Save and reset 'cpo' -let s:save_cpo = &cpo -set cpo&vim - -try - call funcref#Function('') -catch /.*/ - echoe "you're missing vim-addon-mw-utils. See install instructions at ".expand('<sfile>:h:h').'/README.md' -endtry - -if (!exists('g:snipMateSources')) - let g:snipMateSources = {} - " Default source: get snippets based on runtimepath - let g:snipMateSources['default'] = funcref#Function('snipMate#DefaultPool') -endif - -augroup SnipMateDetect - au BufRead,BufNewFile *.snippet,*.snippets setlocal filetype=snippets - au FileType snippets if expand('<afile>:e') =~# 'snippet$' - \ | setlocal syntax=snippet - \ | else - \ | setlocal syntax=snippets - \ | endif -augroup END - -inoremap <silent> <Plug>snipMateNextOrTrigger <C-R>=snipMate#TriggerSnippet()<CR> -snoremap <silent> <Plug>snipMateNextOrTrigger <Esc>a<C-R>=snipMate#TriggerSnippet()<CR> -inoremap <silent> <Plug>snipMateTrigger <C-R>=snipMate#TriggerSnippet(1)<CR> -inoremap <silent> <Plug>snipMateBack <C-R>=snipMate#BackwardsSnippet()<CR> -snoremap <silent> <Plug>snipMateBack <Esc>a<C-R>=snipMate#BackwardsSnippet()<CR> -inoremap <silent> <Plug>snipMateShow <C-R>=snipMate#ShowAvailableSnips()<CR> -xnoremap <silent> <Plug>snipMateVisual :<C-U>call <SID>grab_visual()<CR>gv"_c - -" config variables -if !exists('g:snips_author') - let g:snips_author = 'Me' -endif -if !exists('g:snipMate') - let g:snipMate = {} -endif - -" SnipMate inserts this string when no snippet expansion can be done -let g:snipMate['no_match_completion_feedkeys_chars'] = - \ get(g:snipMate, 'no_match_completion_feedkeys_chars', "\t") - -" Add default scope aliases, without overriding user settings -let g:snipMate.scope_aliases = get(g:snipMate, 'scope_aliases', {}) -if exists('g:snipMate_no_default_aliases') - echom 'The g:snipMate_no_default_aliases option has been renamed.' - \ 'See :h snipMate-options.' -endif -if (!exists('g:snipMate_no_default_aliases') || !g:snipMate_no_default_aliases) - \ && (!exists('g:snipMate.no_default_aliases') - \ || !g:snipMate.no_default_aliases) - let g:snipMate.scope_aliases.objc = - \ get(g:snipMate.scope_aliases, 'objc', 'c') - let g:snipMate.scope_aliases.cpp = - \ get(g:snipMate.scope_aliases, 'cpp', 'c') - let g:snipMate.scope_aliases.cu = - \ get(g:snipMate.scope_aliases, 'cu', 'c') - let g:snipMate.scope_aliases.xhtml = - \ get(g:snipMate.scope_aliases, 'xhtml', 'html') - let g:snipMate.scope_aliases.html = - \ get(g:snipMate.scope_aliases, 'html', 'javascript') - let g:snipMate.scope_aliases.php = - \ get(g:snipMate.scope_aliases, 'php', 'php,html,javascript') - let g:snipMate.scope_aliases.ur = - \ get(g:snipMate.scope_aliases, 'ur', 'html,javascript') - let g:snipMate.scope_aliases.mxml = - \ get(g:snipMate.scope_aliases, 'mxml', 'actionscript') - let g:snipMate.scope_aliases.eruby = - \ get(g:snipMate.scope_aliases, 'eruby', 'eruby-rails,html') - let g:snipMate.scope_aliases.scss = - \ get(g:snipMate.scope_aliases, 'scss', 'css') - let g:snipMate.scope_aliases.less = - \ get(g:snipMate.scope_aliases, 'less', 'css') -endif - -let g:snipMate['get_snippets'] = get(g:snipMate, 'get_snippets', funcref#Function("snipMate#GetSnippets")) - -" List of paths where snippets/ dirs are located -let g:snipMate['snippet_dirs'] = get(g:snipMate, 'snippet_dirs', split(&rtp, ',')) -if type(g:snipMate['snippet_dirs']) != type([]) - echohl WarningMsg - echom "g:snipMate['snippet_dirs'] must be a List" - echohl None -endif - -" _ is default scope added always -" -" &ft honors multiple filetypes and syntax such as in set ft=html.javascript syntax=FOO -let g:snipMate['get_scopes'] = get(g:snipMate, 'get_scopes', funcref#Function('return split(&ft,"\\.")+[&syntax, "_"]')) - -" Modified from Luc Hermitte's function on StackOverflow -" <http://stackoverflow.com/a/1534347> -function! s:grab_visual() abort - let a_save = @a - try - normal! gv"ay - let b:snipmate_visual = @a - finally - let @a = a_save - endtry -endfunction - -" TODO: Allow specifying an arbitrary snippets file -function! s:load_scopes(bang, ...) abort - let gb = a:bang ? g: : b: - let gb.snipMate = get(gb, 'snipMate', {}) - let gb.snipMate.scope_aliases = get(gb.snipMate, 'scope_aliases', {}) - let gb.snipMate.scope_aliases['_'] = join(split(get(gb.snipMate.scope_aliases, '_', ''), ',') + a:000, ',') -endfunction - -command! -bang -bar -nargs=+ SnipMateLoadScope - \ call s:load_scopes(<bang>0, <f-args>) - -" Edit snippet files -command! SnipMateOpenSnippetFiles call snipMate#OpenSnippetFiles() - -" restore 'cpo' -let &cpo = s:save_cpo - -" vim:noet:sw=4:ts=4:ft=vim diff --git a/vim/bundle/vim-snipmate/syntax/snippet.vim b/vim/bundle/vim-snipmate/syntax/snippet.vim deleted file mode 100644 index a947356..0000000 --- a/vim/bundle/vim-snipmate/syntax/snippet.vim +++ /dev/null @@ -1,11 +0,0 @@ -" Syntax highlighting for .snippet files (used for snipMate.vim) -" Hopefully this should make snippets a bit nicer to write! -syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand -syn match tabStop '\$\d\+' -syn match snipEscape '\\\\\|\\`' -syn match snipCommand '\%(\\\@<!\%(\\\\\)*\)\@<=`.\{-}\%(\\\@<!\%(\\\\\)*\)\@<=`' - -hi link placeHolder Special -hi link tabStop Special -hi link snipEscape SpecialChar -hi link snipCommand String diff --git a/vim/bundle/vim-snipmate/syntax/snippets.vim b/vim/bundle/vim-snipmate/syntax/snippets.vim deleted file mode 100644 index 63bda4e..0000000 --- a/vim/bundle/vim-snipmate/syntax/snippets.vim +++ /dev/null @@ -1,23 +0,0 @@ -" Syntax highlighting for .snippets files (used for snipMate.vim) -" Hopefully this should make snippets a bit nicer to write! -syn match snipComment '^#.*' -syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand -syn match tabStop '\$\d\+' -syn match snipEscape '\\\\\|\\`' -syn match snipCommand '\%(\\\@<!\%(\\\\\)*\)\@<=`.\{-}\%(\\\@<!\%(\\\\\)*\)\@<=`' -syn match snippet '^snippet.*' contains=multiSnipText,snipKeyword -syn match snippet '^extends.*' contains=snipKeyword -syn match snippet '^version.*' contains=snipKeyword -syn match multiSnipText '\S\+ \zs.*' contained -syn match snipKeyword '^(snippet|extends|version)'me=s+8 contained -syn match snipError "^[^#vse\t].*$" - -hi link snippet Identifier -hi link snipComment Comment -hi link multiSnipText String -hi link snipKeyword Keyword -hi link snipEscape SpecialChar -hi link placeHolder Special -hi link tabStop Special -hi link snipCommand String -hi link snipError Error diff --git a/vim/bundle/vim-snipmate/t/jumping.vim b/vim/bundle/vim-snipmate/t/jumping.vim deleted file mode 100644 index 1c3ab0d..0000000 --- a/vim/bundle/vim-snipmate/t/jumping.vim +++ /dev/null @@ -1,175 +0,0 @@ -function! Setup(snip) abort - return snipMate#expandSnip(join(a:snip, "\n"), 1) -endfunction - -function! s:to_be_file(expected) abort - return a:expected == getline(1,'$') -endfunction - -function! s:to_be_in(item, list) abort - return !empty(filter(copy(a:list), 'v:val is a:item')) -endfunction - -call vspec#customize_matcher('to_be_file', function('s:to_be_file')) -call vspec#customize_matcher('to_be_in', function('s:to_be_in')) - -describe 'snippet state' - - before - enew - let b:snip_state = snipmate#jumping#state() - end - - after - bwipeout! - end - - describe '.remove()' - - it 'removes the state object' - Expect exists('b:snip_state') to_be_true - call b:snip_state.remove() - Expect exists('b:snip_state') to_be_false - end - - it 'removes snippet related autocommands' - function! ReadAutocmds() - redir => autocmds - 0verbose au snipmate_changes * <buffer> - redir END - return split(autocmds, "\n") - endfunction - aug snipmate_changes - au CursorMoved,CursorMovedI <buffer> echo 'event' - aug END - - Expect len(ReadAutocmds()) > 1 - call b:snip_state.remove() - Expect len(ReadAutocmds()) == 1 - end - - end - - describe '.find_next_stop()' - - it 'increments/decrements the stop_no' - let b:snip_state.stops = { 1 : {}, 2 : {} } - let b:snip_state.stop_no = 1 - let b:snip_state.stop_count = 4 - - call b:snip_state.find_next_stop(0) - Expect b:snip_state.stop_no == 2 - call b:snip_state.find_next_stop(1) - Expect b:snip_state.stop_no == 1 - end - - it 'continues iterating if the next/previous stop does not exist' - let b:snip_state.stops = { 3 : {} } - let b:snip_state.stop_count = 6 - let b:snip_state.stop_no = 1 - call b:snip_state.find_next_stop(0) - Expect b:snip_state.stop_no == 3 - let b:snip_state.stop_no = 5 - call b:snip_state.find_next_stop(1) - Expect b:snip_state.stop_no == 3 - end - - it 'does something at the ends' - " - end - - end - - describe '.remove_nested()' - - it 'removes nested mirrors and only nested mirrors' - let mirror = { 'line' : 0 } - let b:snip_state.stops = { 1 : { 'placeholder' : [[2, mirror]] }, - \ 2 : { 'mirrors' : [mirror, {}] } } - - call b:snip_state.remove_nested(1) - Expect len(b:snip_state.stops[2].mirrors) == 1 - Expect b:snip_state.stops[2].mirrors[0] isnot mirror - end - - it 'removes nested stops' - let stop = [2, 'abc'] - let b:snip_state.stops = { 1 : { 'placeholder' : [stop] }, - \ 2 : { 'placeholder' : stop[1:1] } } - - call b:snip_state.remove_nested(1) - Expect len(b:snip_state.stops) == 1 - Expect keys(b:snip_state.stops) == ['1'] - end - - end - - describe '.find_update_objects()' - - it 'finds mirrors/stops on the same line and after cur_stop' - let b:snip_state.stops = { - \ 1 : { 'line' : 1, 'col' : 5, - \ 'placeholder' : ['x'] }, - \ 2 : { 'line' : 1, 'col' : 7, - \ 'mirrors' : [{ 'line' : 1, 'col' : 7 }] } - \ } - let stop = b:snip_state.stops[1] - - call b:snip_state.find_update_objects(stop) - for obj in stop.update_objects - Expect obj to_be_in [ b:snip_state.stops[2], - \ b:snip_state.stops[2].mirrors[0] ] - endfor - end - - it 'finds mirrors/stops on the same line and after cur_stop mirrors' - let b:snip_state.stops = { - \ 1 : { 'line' : 1, 'col' : 5, - \ 'mirrors' : [{ 'line' : 2, 'col' : 5 }], - \ 'placeholder' : ['x'] }, - \ 2 : { 'line' : 2, 'col' : 7, - \ 'mirrors' : [{ 'line' : 2, 'col' : 7 }] } - \ } - let stop = b:snip_state.stops[1] - - call b:snip_state.find_update_objects(stop) - for obj in stop.update_objects - Expect obj to_be_in [ b:snip_state.stops[2], - \ b:snip_state.stops[2].mirrors[0] ] - endfor - end - - it 'ignores mirrors/stops on other lines' - let b:snip_state.stops = { - \ 1 : { 'line' : 2, 'col' : 5, - \ 'placeholder' : ['x'] }, - \ 2 : { 'line' : 1, 'col' : 7, - \ 'mirrors' : [{ 'line' : 1, 'col' : 7 }] }, - \ 3 : { 'line' : 3, 'col' : 7, - \ 'mirrors' : [{ 'line' : 3, 'col' : 7 }] } - \ } - let stop = b:snip_state.stops[1] - - call b:snip_state.find_update_objects(stop) - Expect empty(stop.update_objects) to_be_true - end - - it 'ignores mirrors/stops on the same line but before cur_stop/mirrors' - let b:snip_state.stops = { - \ 1 : { 'line' : 1, 'col' : 5, - \ 'mirrors' : [{ 'line' : 2, 'col' : 5 }], - \ 'placeholder' : ['x'] }, - \ 2 : { 'line' : 1, 'col' : 1, - \ 'mirrors' : [{ 'line' : 2, 'col' : 1 }] }, - \ 3 : { 'line' : 2, 'col' : 3, - \ 'mirrors' : [{ 'line' : 1, 'col' : 3 }] }, - \ } - let stop = b:snip_state.stops[1] - - call b:snip_state.find_update_objects(stop) - Expect empty(stop.update_objects) to_be_true - end - - end - -end diff --git a/vim/bundle/vim-snipmate/t/parser.vim b/vim/bundle/vim-snipmate/t/parser.vim deleted file mode 100644 index c5cf873..0000000 --- a/vim/bundle/vim-snipmate/t/parser.vim +++ /dev/null @@ -1,142 +0,0 @@ -describe 'snippet parser' - - before - function! Parse(snippet, ...) - let [snip, stops] = snipmate#parse#snippet(a:snippet, (a:0 ? a:1 : 1)) - return (a:0 > 1 && a:2) ? [snip, stops] : snip - endfunction - let b:snipmate_visual = 'testvisual' - end - - it 'parses numeric $id and ${id} vars as [id] lists' - let expect = [[[1234567890]]] - Expect Parse('$1234567890') == expect - Expect Parse('${1234567890}') == expect - end - - it 'disregards $ or ${ followed by a non-id' - Expect Parse('$x1') == [['x1']] - Expect Parse('${x}1') == [['x}1']] - Expect Parse('$VISUA1') == [['VISUA1']] - Expect Parse('${VISUA}1') == [['VISUA}1']] - end - - it 'gathers references to each instance of each stop id' - let [snip, b:stops] = Parse('x$1x${2:x$1x}x$1x${1/a/b}x$VISUALx', 1, 1) - function! InstanceFound(list) - return !empty(filter(copy(b:stops[a:list[0]].instances), - \ 'v:val is a:list')) - endfunction - function! CheckList(list) - for item in a:list - if type(item) == type([]) - Expect InstanceFound(item) to_be_true - call CheckList(item) - endif - unlet item " E732 - endfor - endfunction - call CheckList(snip[0]) - end - - it 'parses mirror substitutions ${n/pat/sub} as [n, {...}]' - let expect = [[[1, { 'pat' : 'abc', 'sub' : 'def' }]]] - Expect Parse('${1/abc/def}') == expect - let expect[0][0][1].flags = '' - Expect Parse('${1/abc/def/}') == expect - let expect[0][0][1].flags = 'g' - Expect Parse('${1/abc/def/g}') == expect - end - - it 'reads patterns literally except for "\/"' - Expect Parse('${1/\a\/b/\c\/d\}}') == [[[1, { 'pat' : '\a/b', 'sub' : '\c/d}' }]]] - end - - it 'parses vars with placeholders as [id, placeholder] lists' - Expect Parse('${1:abc}') == [[[1, 'abc']]] - end - - it 'evaluates backtick expressions' - Expect Parse('`fnamemodify("x.y", ":r")`') == [['x']] - end - - it 'parses placeholders for vars and other specials' - let text = 'a `fnamemodify("x.y", ":r")` ${2:(${3/a/b})}' - let expect = ['a x ', [2, '(', [3, { 'pat' : 'a', 'sub' : 'b' }], ')']] - Expect Parse(text) == [expect] - Expect Parse(printf('${1:%s}', text)) == [[[1] + expect]] - end - - it 'converts tabs according to &et, &sts, &sw, &ts' - " &noet -> leave tabs alone - setl noet - Expect Parse("abc\tdef\n\t\tghi") == [["abc\tdef"], ["\t\tghi"]] - - " &et -> &sts or &sw - setl et sts=2 sw=3 - Expect Parse("abc\tdef\n\t\tghi") == [["abc def"], [" ghi"]] - - setl et sts=0 sw=3 - Expect Parse("abc\tdef\n\t\tghi") == [["abc def"], [" ghi"]] - - setl et sts=-1 sw=3 - Expect Parse("abc\tdef\n\t\tghi") == [["abc def"], [" ghi"]] - - " See #227 - if exists('*shiftwidth') - setl et sts=0 sw=0 ts=3 - Expect Parse("abc\tdef\n\t\tghi") == [["abc def"], [" ghi"]] - endif - end - - it 'parses backslashes as escaping the next character or joining lines' - Expect Parse('x\x') == [['xx']] - Expect Parse('x\\x') == [['x\x']] - Expect Parse("x\\\nx") == [['xx']] - Expect Parse('x\$1') == [['x$1']] - Expect Parse('${1:\}}') == [[[1, '}']]] - Expect Parse('`fnamemodify("\`.x", ":r")`') == [['`']] - Expect Parse('\`x\`') == [['`x`']] - end - - it 'splits text at newlines' - Expect Parse("x\nx") == [['x'], ['x']] - end - - it 'joins evaluated expressions to surrounding text on the same line' - let g:foo = 'bar' - Expect Parse("x`g:foo`x") == [['xbarx']] - Expect Parse("x`g:foo`\nx") == [['xbar'], ['x']] - Expect Parse("x\n`g:foo`x") == [['x'], ['barx']] - end - - it 'expands $VISUAL placeholders with any indents' - Expect Parse("x$VISUALx") == [['xtestvisualx']] - let b:snipmate_visual = " foo\nbar\n baz" - setl noet - Expect Parse("\tx\n\t$VISUAL\nx") == [["\tx"], ["\t foo"], ["\tbar"], - \ ["\t baz"], ["x"]] - end - - it 'determines which var with an id is the stop' - let [snip, stops] = Parse("$1$1$1", 0, 1) - Expect snip == [[[1, "", stops[1]], [1, {}], [1, {}]]] - - let [snip, stops] = Parse("$1${1}$1", 0, 1) - Expect snip == [[[1, "", stops[1]], [1, {}], [1, {}]]] - - let [snip, stops] = Parse("$1${1:}$1", 0, 1) - Expect snip == [[[1, {}], [1, "", stops[1]], [1, {}]]] - - end - - it 'picks the first of many possible stops' - let [snip, stops] = Parse("$1${1:foo}${1:bar}", 0, 1) - Expect snip == [[[1, {}], [1, "foo", stops[1]], [1, {}]]] - end - - it 'represents empty lines as an empty string' - Expect Parse("foo\n\nbar") == [['foo'], [''], ['bar']] - end - -end diff --git a/vim/bundle/vim-snipmate/t/tests.sh b/vim/bundle/vim-snipmate/t/tests.sh deleted file mode 100755 index c1da250..0000000 --- a/vim/bundle/vim-snipmate/t/tests.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/sh - -tmp="$(mktemp || tmpfile)" -vim -Es $tmp <<- EOF - source ~/.vimrc - %delete _ - call append(0, split(&rtp, ',')) - delete _ - wq -EOF - -rtp="$(grep -iE 'vspec|snipmate|tlib|mw-utils' < $tmp | grep -v after)" -vspec="$(grep -iE 'vspec' < $tmp | grep -v after)" -test_files="${*:-parser jumping}" - -for test in $test_files; do - $vspec/bin/vspec $rtp ${test%%.vim}.vim -done - -rm $tmp |