You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
222 lines
7.1 KiB
222 lines
7.1 KiB
func! vundle#config#bundle(arg, ...)
|
|
let bundle = vundle#config#init_bundle(a:arg, a:000)
|
|
call s:rtp_rm_a()
|
|
call add(g:bundles, bundle)
|
|
call s:rtp_add_a()
|
|
return bundle
|
|
endf
|
|
|
|
func! vundle#config#init()
|
|
if !exists('g:bundles') | let g:bundles = [] | endif
|
|
call s:rtp_rm_a()
|
|
let g:bundles = []
|
|
endf
|
|
|
|
func! vundle#config#require(bundles) abort
|
|
for b in a:bundles
|
|
call s:rtp_add(b.rtpath)
|
|
call s:rtp_add(g:bundle_dir)
|
|
" TODO: it has to be relative rtpath, not bundle.name
|
|
exec 'runtime! '.b.name.'/plugin/*.vim'
|
|
exec 'runtime! '.b.name.'/after/*.vim'
|
|
call s:rtp_rm(g:bundle_dir)
|
|
endfor
|
|
endf
|
|
|
|
func! vundle#config#init_bundle(name, opts)
|
|
if a:name != substitute(a:name, '^\s*\(.\{-}\)\s*$', '\1', '')
|
|
echo "Spurious leading and/or trailing whitespace found in bundle spec '" . a:name . "'"
|
|
endif
|
|
let opts = extend(s:parse_options(a:opts), s:parse_name(substitute(a:name,"['".'"]\+','','g')))
|
|
let b = extend(opts, copy(s:bundle))
|
|
let b.rtpath = s:rtpath(opts)
|
|
return b
|
|
endf
|
|
|
|
func! s:parse_options(opts)
|
|
" TODO: improve this
|
|
if len(a:opts) != 1 | return {} | endif
|
|
|
|
if type(a:opts[0]) == type({})
|
|
return a:opts[0]
|
|
else
|
|
return {'rev': a:opts[0]}
|
|
endif
|
|
endf
|
|
|
|
func! s:parse_name(arg)
|
|
let arg = a:arg
|
|
let git_proto = exists('g:vundle_default_git_proto') ? g:vundle_default_git_proto : 'https'
|
|
|
|
if arg =~? '^\s*\(gh\|github\):\S\+'
|
|
\ || arg =~? '^[a-z0-9][a-z0-9-]*/[^/]\+$'
|
|
let uri = git_proto.'://github.com/'.split(arg, ':')[-1]
|
|
if uri !~? '\.git$'
|
|
let uri .= '.git'
|
|
endif
|
|
let name = substitute(split(uri,'\/')[-1], '\.git\s*$','','i')
|
|
elseif arg =~? '^\s*\(git@\|git://\)\S\+'
|
|
\ || arg =~? '\(file\|https\?\)://'
|
|
\ || arg =~? '\.git\s*$'
|
|
let uri = arg
|
|
let name = split( substitute(uri,'/\?\.git\s*$','','i') ,'\/')[-1]
|
|
else
|
|
let name = arg
|
|
let uri = git_proto.'://github.com/vim-scripts/'.name.'.git'
|
|
endif
|
|
return {'name': name, 'uri': uri, 'name_spec': arg }
|
|
endf
|
|
|
|
" this abstracts the operation:
|
|
" 'set runtimepath-=LIST'
|
|
"
|
|
" notes:
|
|
" * it takes care of trailing '/' characters on each of the entries in LIST
|
|
" (it attempts to remove the entry with and without the trailing '/', just
|
|
" in case);
|
|
" * it attempts to do the "real thing", if it can
|
|
" (if 'fnameescape()' is available);
|
|
" * otherwise, it has a number of fallback scenarios, ordered by
|
|
" reliability;
|
|
"
|
|
" args:
|
|
" dirs [string]: described as 'LIST' above;
|
|
"
|
|
" for now, it does not produce an explicit return value
|
|
"
|
|
func! s:compat_rtp_rm_entry(dirs)
|
|
" debug: echomsg '[debug] s:compat_rtp_rm_entry(): entered. rtp: ' . string(&rtp) . '; dirs: ' . string(a:dirs)
|
|
" optimisation: there seems to be a few of these cases
|
|
if empty(a:dirs)
|
|
return 0
|
|
endif
|
|
if exists('*fnameescape')
|
|
exec 'set rtp-='.fnameescape(a:dirs)
|
|
elseif exists('*filter') && exists('*split') && exists('*join') " && ( stridx(a:dir, ',') < 0 )
|
|
" a bit costly, but more compatible
|
|
let l:runtimepath_list = split(&rtp, ',', 1)
|
|
|
|
unlet! g:vundle_config_compat_rtp_rm_entry_dir
|
|
for l:dir_now in split(a:dirs, ',', 1)
|
|
" FIXME: normalise path (think of win32 and other platforms)
|
|
" (fnamemodify()?)
|
|
" get rid of the last slash, if it's not a root directory
|
|
if ( strlen(l:dir_now) > 1 ) && ( l:dir_now[ -1: ] == '/' ) && ( l:dir_now[ -2:-2 ] != ':' )
|
|
let l:dir_now = l:dir_now [ :-2 ]
|
|
endif
|
|
" remove the directory as is (without a trailing '/'),
|
|
" and with a trailing '/', too.
|
|
for l:dir_suff in [ '', '/' ]
|
|
if ( empty(l:dir_now) && ( ! empty(l:dir_suff) ) )
|
|
continue
|
|
endif
|
|
let g:vundle_config_compat_rtp_rm_entry_dir = l:dir_now . l:dir_suff
|
|
let l:runtimepath_list = filter(l:runtimepath_list, 'v:val != g:vundle_config_compat_rtp_rm_entry_dir')
|
|
endfor
|
|
endfor
|
|
unlet! g:vundle_config_compat_rtp_rm_entry_dir
|
|
" assemble the runtime variable from the list
|
|
let &rtp = join(l:runtimepath_list, ',')
|
|
elseif exists('*escape')
|
|
" from fnameescape() documentation:
|
|
" it escapes: " \t\n*?[{`$\\%#'\"|!<"
|
|
" plus, depending on 'isfname', other characters.
|
|
" (TODO: add those cases, if needed)
|
|
exec 'set rtp-='.escape(a:dirs, " \t\n*?[{`$\\%#'\"|!<")
|
|
else
|
|
" cheap and cheerful (but no escaping)
|
|
exec 'set rtp-='.a:dirs
|
|
endif
|
|
" debug: echomsg '[debug] s:compat_rtp_rm_entry(): exiting. rtp: ' . string(&rtp)
|
|
endf
|
|
|
|
" abstracts the following operations:
|
|
" 'set runtimepath^=LIST'
|
|
" 'set runtimepath+=LIST'
|
|
" 'set runtimepath=LIST'
|
|
"
|
|
" args:
|
|
" dirs [string]: described as 'LIST' above;
|
|
" addset_operator [string]: one of:
|
|
" '^': prepend ('set runtimepath^=');
|
|
" '+': append ('set runtimepath+=');
|
|
" '': set ('set runtimepath=');
|
|
"
|
|
" for now, it does not produce an explicit return value
|
|
"
|
|
func! s:compat_rtp_addset_entry(dirs, addset_operator)
|
|
" debug: echomsg '[debug] s:compat_rtp_addset_entry(): entered. rtp: ' . string(&rtp) . '; dirs: ' . string(a:dirs) . '; operator: ' . string( a:addset_operator )
|
|
if exists('*fnameescape')
|
|
exec 'set rtp'.a:addset_operator.'='.fnameescape(a:dirs)
|
|
else
|
|
" almost as quick, but more compatible
|
|
if a:addset_operator == ''
|
|
let &rtp = a:dirs
|
|
else
|
|
let l:elem_separator = ( empty(&rtp) ? '' : ',' )
|
|
" note: ideally, we would want to
|
|
" do nothing if the value already exists
|
|
" (this is what the standard 'set {op}=' expressions do)
|
|
" but, for efficiency, we will let those elements
|
|
" through (besides, s:compat_rtp_rm_entry() would get rid of all
|
|
" matches if we want to do that before or after this operation)
|
|
if a:addset_operator == '^'
|
|
let &rtp = a:dirs . l:elem_separator . &rtp
|
|
elseif a:addset_operator == '+'
|
|
let &rtp = &rtp . l:elem_separator . a:dirs
|
|
else
|
|
" FIXME: internal error
|
|
endif
|
|
endif
|
|
endif
|
|
" debug: echomsg '[debug] s:compat_rtp_addset_entry(): exiting. rtp: ' . string(&rtp)
|
|
endf
|
|
|
|
func! s:rtp_rm_a()
|
|
let paths = map(copy(g:bundles), 'v:val.rtpath')
|
|
if !empty(paths)
|
|
let prepends = join(paths, ',')
|
|
let appends = join(paths, '/after,').'/after'
|
|
call s:compat_rtp_rm_entry(prepends)
|
|
call s:compat_rtp_rm_entry(appends)
|
|
endif
|
|
endf
|
|
|
|
func! s:rtp_add_a()
|
|
let paths = map(copy(g:bundles), 'v:val.rtpath')
|
|
if !empty(paths)
|
|
let prepends = join(paths, ',')
|
|
let appends = join(paths, '/after,').'/after'
|
|
call s:compat_rtp_addset_entry(prepends,'^')
|
|
call s:compat_rtp_addset_entry(appends,'+')
|
|
endif
|
|
endf
|
|
|
|
func! s:rtp_rm(dir) abort
|
|
if !empty(a:dir)
|
|
call s:compat_rtp_rm_entry(expand(a:dir, 1))
|
|
call s:compat_rtp_rm_entry(expand(a:dir.'/after', 1))
|
|
endif
|
|
endf
|
|
|
|
func! s:rtp_add(dir) abort
|
|
if !empty(a:dir)
|
|
call s:compat_rtp_addset_entry(expand(a:dir, 1), '^')
|
|
call s:compat_rtp_addset_entry(expand(a:dir.'/after', 1), '+')
|
|
endif
|
|
endf
|
|
|
|
func! s:expand_path(path) abort
|
|
return simplify(expand(a:path, 1))
|
|
endf
|
|
|
|
func! s:rtpath(opts)
|
|
return has_key(a:opts, 'rtp') ? s:expand_path(a:opts.path().'/'.a:opts.rtp) : a:opts.path()
|
|
endf
|
|
|
|
let s:bundle = {}
|
|
|
|
func! s:bundle.path()
|
|
return s:expand_path(g:bundle_dir.'/'.self.name)
|
|
endf
|
|
|