279 lines
10 KiB
VimL
279 lines
10 KiB
VimL
" ---------------------------------------------------------------------------
|
|
" Add a plugin to the runtimepath.
|
|
"
|
|
" arg -- a string specifying the plugin
|
|
" ... -- a dictionary of options for the plugin
|
|
" return -- the return value from vundle#config#init_bundle()
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#config#bundle(arg, ...)
|
|
let bundle = vundle#config#init_bundle(a:arg, a:000)
|
|
if !s:check_bundle_name(bundle)
|
|
return
|
|
endif
|
|
if exists('g:vundle_lazy_load') && g:vundle_lazy_load
|
|
call add(g:bundles, bundle)
|
|
else
|
|
call s:rtp_rm_a()
|
|
call add(g:bundles, bundle)
|
|
call s:rtp_add_a()
|
|
call s:rtp_add_defaults()
|
|
endif
|
|
return bundle
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" When lazy bundle load is used (begin/end functions), add all configured
|
|
" bundles to runtimepath and reorder appropriately.
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#config#activate_bundles()
|
|
call s:rtp_add_a()
|
|
call s:rtp_add_defaults()
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Initialize Vundle.
|
|
"
|
|
" Start a new bundles list and make sure the runtimepath does not contain
|
|
" directories from a previous call. In theory, this should only be called
|
|
" once.
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#config#init()
|
|
if !exists('g:bundles') | let g:bundles = [] | endif
|
|
call s:rtp_rm_a()
|
|
let g:bundles = []
|
|
let g:bundle_names = {}
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Add a list of bundles to the runtimepath and source them.
|
|
"
|
|
" bundles -- a list of bundle objects
|
|
" ---------------------------------------------------------------------------
|
|
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
|
|
call s:rtp_add_defaults()
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Create a bundle object from a bundle specification.
|
|
"
|
|
" name -- the bundle specification as a string
|
|
" opts -- the options dictionary from then bundle definition
|
|
" return -- an initialized bundle object
|
|
" ---------------------------------------------------------------------------
|
|
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 plugin spec '" . a:name . "'"
|
|
endif
|
|
let opts = extend(s:parse_options(a:opts), s:parse_name(substitute(a:name,"['".'"]\+','','g')), 'keep')
|
|
let b = extend(opts, copy(s:bundle))
|
|
let b.rtpath = s:rtpath(opts)
|
|
return b
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Check if the current bundle name has already been used in this running
|
|
" instance and show an error to that effect.
|
|
"
|
|
" bundle -- a bundle object whose name is to be checked
|
|
" return -- 0 if the bundle's name has been seen before, 1 otherwise
|
|
" ---------------------------------------------------------------------------
|
|
funct! s:check_bundle_name(bundle)
|
|
if has_key(g:bundle_names, a:bundle.name)
|
|
echoerr 'Vundle error: Name collision for Plugin ' . a:bundle.name_spec .
|
|
\ '. Plugin ' . g:bundle_names[a:bundle.name] .
|
|
\ ' previously used the name "' . a:bundle.name . '"' .
|
|
\ '. Skipping Plugin ' . a:bundle.name_spec . '.'
|
|
return 0
|
|
endif
|
|
let g:bundle_names[a:bundle.name] = a:bundle.name_spec
|
|
return 1
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Parse the options which can be supplied with the bundle specification.
|
|
" Corresponding documentation: vundle-plugins-configure
|
|
"
|
|
" opts -- a dictionary with the user supplied options for the bundle
|
|
" return -- a dictionary with the user supplied options for the bundle, this
|
|
" will be merged with a s:bundle object into one dictionary.
|
|
" ---------------------------------------------------------------------------
|
|
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
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Parse the plugin specification. Corresponding documentation:
|
|
" vundle-plugins-uris
|
|
"
|
|
" arg -- the string supplied to identify the plugin
|
|
" return -- a dictionary with the folder name (key 'name') and the uri (key
|
|
" 'uri') for cloning the plugin and the original argument (key
|
|
" 'name_spec')
|
|
" ---------------------------------------------------------------------------
|
|
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
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Modify the runtimepath, after all bundles have been added, so that the
|
|
" directories that were in the default runtimepath appear first in the list
|
|
" (with their 'after' directories last).
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtp_add_defaults()
|
|
let current = &rtp
|
|
set rtp&vim
|
|
let default = &rtp
|
|
let &rtp = current
|
|
let default_rtp_items = split(default, ',')
|
|
if !empty(default_rtp_items)
|
|
let first_item = fnameescape(default_rtp_items[0])
|
|
exec 'set rtp-=' . first_item
|
|
exec 'set rtp^=' . first_item
|
|
endif
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Remove all paths for the plugins which are managed by Vundle from the
|
|
" runtimepath.
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtp_rm_a()
|
|
let paths = map(copy(g:bundles), 'v:val.rtpath')
|
|
let prepends = join(paths, ',')
|
|
let appends = join(paths, '/after,').'/after'
|
|
exec 'set rtp-='.fnameescape(prepends)
|
|
exec 'set rtp-='.fnameescape(appends)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Add all paths for the plugins which are managed by Vundle to the
|
|
" runtimepath.
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtp_add_a()
|
|
let paths = map(copy(g:bundles), 'v:val.rtpath')
|
|
let prepends = join(paths, ',')
|
|
let appends = join(paths, '/after,').'/after'
|
|
exec 'set rtp^='.fnameescape(prepends)
|
|
exec 'set rtp+='.fnameescape(appends)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Remove a directory and the corresponding 'after' directory from runtimepath.
|
|
"
|
|
" dir -- the directory name to be removed as a string. The corresponding
|
|
" 'after' directory will also be removed.
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtp_rm(dir) abort
|
|
exec 'set rtp-='.fnameescape(expand(a:dir, 1))
|
|
exec 'set rtp-='.fnameescape(expand(a:dir.'/after', 1))
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Add a directory and the corresponding 'after' directory to runtimepath.
|
|
"
|
|
" dir -- the directory name to be added as a string. The corresponding
|
|
" 'after' directory will also be added.
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtp_add(dir) abort
|
|
exec 'set rtp^='.fnameescape(expand(a:dir, 1))
|
|
exec 'set rtp+='.fnameescape(expand(a:dir.'/after', 1))
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Expand and simplify a path.
|
|
"
|
|
" path -- the path to expand as a string
|
|
" return -- the expanded and simplified path
|
|
" ---------------------------------------------------------------------------
|
|
func! s:expand_path(path) abort
|
|
return simplify(expand(a:path, 1))
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Find the actual path inside a bundle directory to be added to the
|
|
" runtimepath. It might be provided by the user with the 'rtp' option.
|
|
" Corresponding documentation: vundle-plugins-configure
|
|
"
|
|
" opts -- a bundle dict
|
|
" return -- expanded path to the corresponding plugin directory
|
|
" ---------------------------------------------------------------------------
|
|
func! s:rtpath(opts)
|
|
return has_key(a:opts, 'rtp') ? s:expand_path(a:opts.path().'/'.a:opts.rtp) : a:opts.path()
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" a bundle 'object'
|
|
" ---------------------------------------------------------------------------
|
|
let s:bundle = {}
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Return the absolute path to the directory inside the bundle directory
|
|
" (prefix) where thr bundle will be cloned.
|
|
"
|
|
" return -- the target location to clone this bundle to
|
|
" ---------------------------------------------------------------------------
|
|
func! s:bundle.path()
|
|
return s:expand_path(g:bundle_dir.'/'.self.name)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Determine if the bundle has the pinned attribute set in the config
|
|
"
|
|
" return -- 1 if the bundle is pinned, 0 otherwise
|
|
" ---------------------------------------------------------------------------
|
|
func! s:bundle.is_pinned()
|
|
return get(self, 'pinned')
|
|
endf
|
|
|
|
" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl:
|