-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
0 parents
commit d166934
Showing
103 changed files
with
39,785 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,139 @@ | ||
" pathogen.vim - path option manipulation | ||
" Maintainer: Tim Pope <vimNOSPAM@tpope.org> | ||
" Version: 1.2 | ||
|
||
" Install in ~/.vim/autoload (or ~\vimfiles\autoload). | ||
" | ||
" API is documented below. | ||
|
||
if exists("g:loaded_pathogen") || &cp | ||
finish | ||
endif | ||
let g:loaded_pathogen = 1 | ||
|
||
" Split a path into a list. | ||
function! pathogen#split(path) abort " {{{1 | ||
if type(a:path) == type([]) | return a:path | endif | ||
let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,') | ||
return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")') | ||
endfunction " }}}1 | ||
|
||
" Convert a list to a path. | ||
function! pathogen#join(...) abort " {{{1 | ||
if type(a:1) == type(1) && a:1 | ||
let i = 1 | ||
let space = ' ' | ||
else | ||
let i = 0 | ||
let space = '' | ||
endif | ||
let path = "" | ||
while i < a:0 | ||
if type(a:000[i]) == type([]) | ||
let list = a:000[i] | ||
let j = 0 | ||
while j < len(list) | ||
let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g') | ||
let path .= ',' . escaped | ||
let j += 1 | ||
endwhile | ||
else | ||
let path .= "," . a:000[i] | ||
endif | ||
let i += 1 | ||
endwhile | ||
return substitute(path,'^,','','') | ||
endfunction " }}}1 | ||
|
||
" Convert a list to a path with escaped spaces for 'path', 'tag', etc. | ||
function! pathogen#legacyjoin(...) abort " {{{1 | ||
return call('pathogen#join',[1] + a:000) | ||
endfunction " }}}1 | ||
|
||
" Remove duplicates from a list. | ||
function! pathogen#uniq(list) abort " {{{1 | ||
let i = 0 | ||
let seen = {} | ||
while i < len(a:list) | ||
if has_key(seen,a:list[i]) | ||
call remove(a:list,i) | ||
else | ||
let seen[a:list[i]] = 1 | ||
let i += 1 | ||
endif | ||
endwhile | ||
return a:list | ||
endfunction " }}}1 | ||
|
||
" Returns a hash indicating which filetype features are enabled. | ||
function! pathogen#filetype() abort " {{{1 | ||
redir => output | ||
silent filetype | ||
redir END | ||
let result = {} | ||
let result.detection = match(output,'detection:ON') >= 0 | ||
let result.indent = match(output,'indent:ON') >= 0 | ||
let result.plugin = match(output,'plugin:ON') >= 0 | ||
return result | ||
endfunction " }}}1 | ||
|
||
" \ on Windows unless shellslash is set, / everywhere else. | ||
function! pathogen#separator() abort " {{{1 | ||
return !exists("+shellslash") || &shellslash ? '/' : '\' | ||
endfunction " }}}1 | ||
|
||
" Convenience wrapper around glob() which returns a list. | ||
function! pathogen#glob(pattern) abort " {{{1 | ||
let files = split(glob(a:pattern),"\n") | ||
return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")') | ||
endfunction "}}}1 | ||
|
||
" Like pathogen#glob(), only limit the results to directories. | ||
function! pathogen#glob_directories(pattern) abort " {{{1 | ||
return filter(pathogen#glob(a:pattern),'isdirectory(v:val)') | ||
endfunction "}}}1 | ||
|
||
" Prepend all subdirectories of path to the rtp, and append all after | ||
" directories in those subdirectories. | ||
function! pathogen#runtime_prepend_subdirectories(path) " {{{1 | ||
let sep = pathogen#separator() | ||
let before = pathogen#glob_directories(a:path.sep."*[^~]") | ||
let after = pathogen#glob_directories(a:path.sep."*[^~]".sep."after") | ||
let rtp = pathogen#split(&rtp) | ||
let path = expand(a:path) | ||
call filter(rtp,'v:val[0:strlen(path)-1] !=# path') | ||
let &rtp = pathogen#join(pathogen#uniq(before + rtp + after)) | ||
return &rtp | ||
endfunction " }}}1 | ||
|
||
" For each directory in rtp, check for a subdirectory named dir. If it | ||
" exists, add all subdirectories of that subdirectory to the rtp, immediately | ||
" after the original directory. If no argument is given, 'bundle' is used. | ||
" Repeated calls with the same arguments are ignored. | ||
function! pathogen#runtime_append_all_bundles(...) " {{{1 | ||
let sep = pathogen#separator() | ||
let name = a:0 ? a:1 : 'bundle' | ||
let list = [] | ||
for dir in pathogen#split(&rtp) | ||
if dir =~# '\<after$' | ||
let list += pathogen#glob_directories(substitute(dir,'after$',name.sep.'*[^~]'.sep.'after','')) + [dir] | ||
else | ||
let list += [dir] + pathogen#glob_directories(dir.sep.name.sep.'*[^~]') | ||
endif | ||
endfor | ||
let &rtp = pathogen#join(pathogen#uniq(list)) | ||
return 1 | ||
endfunction | ||
|
||
" }}}1 | ||
|
||
" Invoke :helptags on all non-$VIM doc directories in runtimepath. | ||
function! pathogen#helptags() " {{{1 | ||
for dir in pathogen#split(&rtp) | ||
if dir[0 : strlen($VIM)-1] !=# $VIM && isdirectory(dir.'/doc') && (!filereadable(dir.'/doc/tags') || filewritable(dir.'/doc/tags')) | ||
helptags `=dir.'/doc'` | ||
endif | ||
endfor | ||
endfunction " }}}1 | ||
|
||
" vim:set ft=vim ts=8 sw=2 sts=2: |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,72 @@ | ||
" repeat.vim - Let the repeat command repeat plugin maps | ||
" Maintainer: Tim Pope | ||
" Version: 1.0 | ||
|
||
" Installation: | ||
" Place in either ~/.vim/plugin/repeat.vim (to load at start up) or | ||
" ~/.vim/autoload/repeat.vim (to load automatically as needed). | ||
" | ||
" Developers: | ||
" Basic usage is as follows: | ||
" | ||
" silent! call repeat#set("\<Plug>MappingToRepeatCommand",3) | ||
" | ||
" The first argument is the mapping that will be invoked when the |.| key is | ||
" pressed. Typically, it will be the same as the mapping the user invoked. | ||
" This sequence will be stuffed into the input queue literally. Thus you must | ||
" encode special keys by prefixing them with a backslash inside double quotes. | ||
" | ||
" The second argument is the default count. This is the number that will be | ||
" prefixed to the mapping if no explicit numeric argument was given. The | ||
" value of the v:count variable is usually correct and it will be used if the | ||
" second parameter is omitted. If your mapping doesn't accept a numeric | ||
" argument and you never want to receive one, pass a value of -1. | ||
" | ||
" Make sure to call the repeat#set function _after_ making changes to the | ||
" file. | ||
|
||
if exists("g:loaded_repeat") || &cp || v:version < 700 | ||
finish | ||
endif | ||
let g:loaded_repeat = 1 | ||
|
||
let g:repeat_tick = -1 | ||
|
||
function! repeat#set(sequence,...) | ||
silent exe "norm! \"=''\<CR>p" | ||
let g:repeat_sequence = a:sequence | ||
let g:repeat_count = a:0 ? a:1 : v:count | ||
let g:repeat_tick = b:changedtick | ||
endfunction | ||
|
||
function! s:repeat(count) | ||
if g:repeat_tick == b:changedtick | ||
let c = g:repeat_count | ||
let s = g:repeat_sequence | ||
let cnt = c == -1 ? "" : (a:count ? a:count : (c ? c : '')) | ||
call feedkeys(cnt . s) | ||
else | ||
call feedkeys((a:count ? a:count : '') . '.', 'n') | ||
endif | ||
endfunction | ||
|
||
function! s:wrap(command,count) | ||
let preserve = (g:repeat_tick == b:changedtick) | ||
exe 'norm! '.(a:count ? a:count : '').a:command | ||
if preserve | ||
let g:repeat_tick = b:changedtick | ||
endif | ||
endfunction | ||
|
||
nnoremap <silent> . :<C-U>call <SID>repeat(v:count)<CR> | ||
nnoremap <silent> u :<C-U>call <SID>wrap('u',v:count)<CR> | ||
nnoremap <silent> U :<C-U>call <SID>wrap('U',v:count)<CR> | ||
nnoremap <silent> <C-R> :<C-U>call <SID>wrap("\<Lt>C-R>",v:count)<CR> | ||
augroup repeatPlugin | ||
autocmd! | ||
autocmd BufLeave,BufWritePre,BufReadPre * let g:repeat_tick = (g:repeat_tick == b:changedtick || g:repeat_tick == 0) ? 0 : -1 | ||
autocmd BufEnter,BufWritePost * if g:repeat_tick == 0|let g:repeat_tick = b:changedtick|endif | ||
augroup END | ||
|
||
" vim:set ft=vim et sw=4 sts=4: |
Oops, something went wrong.