356f245fbe
All global variables that are not part of the public API (mentioned in the documentation) are turned into autoload variables. This is intended to give all global variables defined by Vundle.vim a common prefix. The variable g:default_git_proto is part of the public API and is therefor not changed. This is the only exception. Changed: g:bundle_dir -> vundle#bundle_dir g:bundles -> vundle#bundles g:updated_bundles -> vundle#updated_bundles g:vundle_lazy_load -> vundle#lazy_load g:vundle_log -> vundle#log Unchanged: g:default_git_proto
548 lines
18 KiB
VimL
548 lines
18 KiB
VimL
" ---------------------------------------------------------------------------
|
|
" Try to clone all new bundles given (or all bundles in g:vundle#bundles by
|
|
" default) to g:vundle#bundle_dir. If a:bang is 1 it will also update all
|
|
" plugins (git pull).
|
|
"
|
|
" bang -- 1 or 0
|
|
" ... -- any number of bundle specifications (separate arguments)
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#new(bang, ...) abort
|
|
" No specific plugins are specified. Operate on all plugins.
|
|
if a:0 == 0
|
|
let bundles = g:vundle#bundles
|
|
" Specific plugins are specified for update. Update them.
|
|
elseif (a:bang)
|
|
let bundles = filter(copy(g:vundle#bundles), 'index(a:000, v:val.name) > -1')
|
|
" Specific plugins are specified for installation. Install them.
|
|
else
|
|
let bundles = map(copy(a:000), 'vundle#config#bundle(v:val, {})')
|
|
endif
|
|
|
|
if empty(bundles)
|
|
echoerr 'No bundles were selected for operation'
|
|
return
|
|
endif
|
|
|
|
let names = vundle#scripts#bundle_names(map(copy(bundles), 'v:val.name_spec'))
|
|
call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:vundle#bundle_dir, 1)], names + ['Helptags'])
|
|
|
|
" This calls 'add' as a normal mode command. This is a buffer local mapping
|
|
" defined in vundle#scripts#view(). The mapping will call a buffer local
|
|
" command InstallPlugin which in turn will call vundle#installer#run() with
|
|
" vundle#installer#install().
|
|
call s:process(a:bang, (a:bang ? 'add!' : 'add'))
|
|
|
|
call vundle#config#require(bundles)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Iterate over all lines in a Vundle window and execute the given command for
|
|
" every line. Used by the installation and cleaning functions.
|
|
"
|
|
" bang -- not used (FIXME)
|
|
" cmd -- the (normal mode) command to execute for every line as a string
|
|
" ---------------------------------------------------------------------------
|
|
func! s:process(bang, cmd)
|
|
let msg = ''
|
|
|
|
redraw
|
|
sleep 1m
|
|
|
|
let lines = (getline('.','$')[0:-2])
|
|
|
|
for line in lines
|
|
redraw
|
|
|
|
exec ':norm '.a:cmd
|
|
|
|
if 'error' == s:last_status
|
|
let msg = 'With errors; press l to view log'
|
|
endif
|
|
|
|
if 'updated' == s:last_status && empty(msg)
|
|
let msg = 'Plugins updated; press u to view changelog'
|
|
endif
|
|
|
|
" goto next one
|
|
exec ':+1'
|
|
|
|
setl nomodified
|
|
endfor
|
|
|
|
redraw
|
|
echo 'Done! '.msg
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Call another function in the different Vundle windows.
|
|
"
|
|
" func_name -- the function to call
|
|
" name -- the bundle name to call func_name for (string)
|
|
" ... -- the argument to be used when calling func_name (only the first
|
|
" optional argument will be used)
|
|
" return -- the status returned by the call to func_name
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#run(func_name, name, ...) abort
|
|
let n = a:name
|
|
|
|
echo 'Processing '.n
|
|
call s:sign('active')
|
|
|
|
sleep 1m
|
|
|
|
let status = call(a:func_name, a:1)
|
|
|
|
call s:sign(status)
|
|
|
|
redraw
|
|
|
|
if 'new' == status
|
|
echo n.' installed'
|
|
elseif 'updated' == status
|
|
echo n.' updated'
|
|
elseif 'todate' == status
|
|
echo n.' already installed'
|
|
elseif 'deleted' == status
|
|
echo n.' deleted'
|
|
elseif 'helptags' == status
|
|
echo n.' regenerated'
|
|
elseif 'pinned' == status
|
|
echo n.' pinned'
|
|
elseif 'error' == status
|
|
echohl Error
|
|
echo 'Error processing '.n
|
|
echohl None
|
|
sleep 1
|
|
else
|
|
throw 'whoops, unknown status:'.status
|
|
endif
|
|
|
|
let s:last_status = status
|
|
|
|
return status
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Put a sign on the current line, indicating the status of the installation
|
|
" step.
|
|
"
|
|
" status -- string describing the status
|
|
" ---------------------------------------------------------------------------
|
|
func! s:sign(status)
|
|
if (!has('signs'))
|
|
return
|
|
endif
|
|
|
|
exe ":sign place ".line('.')." line=".line('.')." name=Vu_". a:status ." buffer=" . bufnr("%")
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Install a plugin, then add it to the runtimepath and source it.
|
|
"
|
|
" bang -- 1 or 0, passed directly to vundle#installer#install()
|
|
" name -- the name of a bundle (string)
|
|
" return -- the return value from vundle#installer#install()
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#install_and_require(bang, name) abort
|
|
let result = vundle#installer#install(a:bang, a:name)
|
|
let b = vundle#config#bundle(a:name, {})
|
|
call vundle#installer#helptags([b])
|
|
call vundle#config#require([b])
|
|
return result
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Install or update a bundle given by its name.
|
|
"
|
|
" bang -- 1 or 0, passed directly to s:sync()
|
|
" name -- the name of a bundle (string)
|
|
" return -- the return value from s:sync()
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#install(bang, name) abort
|
|
if !isdirectory(g:vundle#bundle_dir) | call mkdir(g:vundle#bundle_dir, 'p') | endif
|
|
|
|
let n = substitute(a:name,"['".'"]\+','','g')
|
|
let matched = filter(copy(g:vundle#bundles), 'v:val.name_spec == n')
|
|
|
|
if len(matched) > 0
|
|
let b = matched[0]
|
|
else
|
|
let b = vundle#config#init_bundle(a:name, {})
|
|
endif
|
|
|
|
return s:sync(a:bang, b)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Call :helptags for all bundles in g:vundle#bundles.
|
|
"
|
|
" return -- 'error' if an error occurred, else return 'helptags'
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#docs() abort
|
|
let error_count = vundle#installer#helptags(g:vundle#bundles)
|
|
if error_count > 0
|
|
return 'error'
|
|
endif
|
|
return 'helptags'
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Call :helptags for a list of bundles.
|
|
"
|
|
" bundles -- a list of bundle dictionaries for which :helptags should be
|
|
" called.
|
|
" return -- the number of directories where :helptags failed
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#helptags(bundles) abort
|
|
let bundle_dirs = map(copy(a:bundles),'v:val.rtpath')
|
|
let help_dirs = filter(bundle_dirs, 's:has_doc(v:val)')
|
|
|
|
call s:log('')
|
|
call s:log('Helptags:')
|
|
|
|
let statuses = map(copy(help_dirs), 's:helptags(v:val)')
|
|
let errors = filter(statuses, 'v:val == 0')
|
|
|
|
call s:log('Helptags: '.len(help_dirs).' plugins processed')
|
|
|
|
return len(errors)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" List all installed plugins.
|
|
" Corresponding documentation: vundle-plugins-list
|
|
"
|
|
" bang -- not used
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#list(bang) abort
|
|
let bundles = vundle#scripts#bundle_names(map(copy(g:vundle#bundles), 'v:val.name_spec'))
|
|
call vundle#scripts#view('list', ['" My Plugins'], bundles)
|
|
redraw
|
|
echo len(g:vundle#bundles).' plugins configured'
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" List and remove all directories in the bundle directory which are not
|
|
" activated (added to the bundle list).
|
|
"
|
|
" bang -- 0 if the user should be asked to confirm every deletion, 1 if they
|
|
" should be removed unconditionally
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#clean(bang) abort
|
|
let bundle_dirs = map(copy(g:vundle#bundles), 'v:val.path()')
|
|
let all_dirs = (v:version > 702 || (v:version == 702 && has("patch51")))
|
|
\ ? split(globpath(g:vundle#bundle_dir, '*', 1), "\n")
|
|
\ : split(globpath(g:vundle#bundle_dir, '*'), "\n")
|
|
let x_dirs = filter(all_dirs, '0 > index(bundle_dirs, v:val)')
|
|
|
|
if empty(x_dirs)
|
|
let headers = ['" All clean!']
|
|
let names = []
|
|
else
|
|
let headers = ['" Removing Plugins:']
|
|
let names = vundle#scripts#bundle_names(map(copy(x_dirs), 'fnamemodify(v:val, ":t")'))
|
|
end
|
|
|
|
call vundle#scripts#view('clean', headers, names)
|
|
redraw
|
|
|
|
if (a:bang || empty(names))
|
|
call s:process(a:bang, 'D')
|
|
else
|
|
call inputsave()
|
|
let response = input('Continue? [Y/n]: ')
|
|
call inputrestore()
|
|
if (response =~? 'y' || response == '')
|
|
call s:process(a:bang, 'D')
|
|
endif
|
|
endif
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Delete to directory for a plugin.
|
|
"
|
|
" bang -- not used
|
|
" dir_name -- the bundle directory to be deleted (as a string)
|
|
" return -- 'error' if an error occurred, 'deleted' if the plugin folder was
|
|
" successfully deleted
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#delete(bang, dir_name) abort
|
|
|
|
let cmd = ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh'))) ?
|
|
\ 'rmdir /S /Q' :
|
|
\ 'rm -rf'
|
|
|
|
let bundle = vundle#config#init_bundle(a:dir_name, {})
|
|
let cmd .= ' '.vundle#installer#shellesc(bundle.path())
|
|
|
|
let out = s:system(cmd)
|
|
|
|
call s:log('')
|
|
call s:log('Plugin '.a:dir_name)
|
|
call s:log(cmd, '$ ')
|
|
call s:log(out, '> ')
|
|
|
|
if 0 != v:shell_error
|
|
return 'error'
|
|
else
|
|
return 'deleted'
|
|
endif
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Check if a bundled plugin has any documentation.
|
|
"
|
|
" rtp -- a path (string) where the plugin is installed
|
|
" return -- 1 if some documentation was found, 0 otherwise
|
|
" ---------------------------------------------------------------------------
|
|
func! s:has_doc(rtp) abort
|
|
return isdirectory(a:rtp.'/doc')
|
|
\ && (!filereadable(a:rtp.'/doc/tags') || filewritable(a:rtp.'/doc/tags'))
|
|
\ && (v:version > 702 || (v:version == 702 && has("patch51")))
|
|
\ ? !(empty(glob(a:rtp.'/doc/*.txt', 1)) && empty(glob(a:rtp.'/doc/*.??x', 1)))
|
|
\ : !(empty(glob(a:rtp.'/doc/*.txt')) && empty(glob(a:rtp.'/doc/*.??x')))
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Update the helptags for a plugin.
|
|
"
|
|
" rtp -- the path to the plugin's root directory (string)
|
|
" return -- 1 if :helptags succeeded, 0 otherwise
|
|
" ---------------------------------------------------------------------------
|
|
func! s:helptags(rtp) abort
|
|
" it is important to keep trailing slash here
|
|
let doc_path = resolve(a:rtp . '/doc/')
|
|
call s:log(':helptags '.doc_path)
|
|
try
|
|
execute 'helptags ' . doc_path
|
|
catch
|
|
call s:log("> Error running :helptags ".doc_path)
|
|
return 0
|
|
endtry
|
|
return 1
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Get the URL for the remote called 'origin' on the repository that
|
|
" corresponds to a given bundle.
|
|
"
|
|
" bundle -- a bundle object to check the repository for
|
|
" return -- the URL for the origin remote (string)
|
|
" ---------------------------------------------------------------------------
|
|
func! s:get_current_origin_url(bundle) abort
|
|
let cmd = 'cd '.vundle#installer#shellesc(a:bundle.path()).' && git config --get remote.origin.url'
|
|
let cmd = vundle#installer#shellesc_cd(cmd)
|
|
let out = s:strip(s:system(cmd))
|
|
return out
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Get a short sha of the HEAD of the repository for a given bundle
|
|
"
|
|
" bundle -- a bundle object
|
|
" return -- A 15 character log sha for the current HEAD
|
|
" ---------------------------------------------------------------------------
|
|
func! s:get_current_sha(bundle)
|
|
let cmd = 'cd '.vundle#installer#shellesc(a:bundle.path()).' && git rev-parse HEAD'
|
|
let cmd = vundle#installer#shellesc_cd(cmd)
|
|
let out = s:system(cmd)[0:15]
|
|
return out
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Create the appropriate sync command to run according to the current state of
|
|
" the local repository (clone, pull, reset, etc).
|
|
"
|
|
" In the case of a pull (update), also return the current sha, so that we can
|
|
" later check that there has been an upgrade.
|
|
"
|
|
" bang -- 0 if only new plugins should be installed, 1 if existing plugins
|
|
" should be updated
|
|
" bundle -- a bundle object to create the sync command for
|
|
" return -- A list containing the command to run and the sha for the current
|
|
" HEAD
|
|
" ---------------------------------------------------------------------------
|
|
func! s:make_sync_command(bang, bundle) abort
|
|
let git_dir = expand(a:bundle.path().'/.git/', 1)
|
|
if isdirectory(git_dir) || filereadable(expand(a:bundle.path().'/.git', 1))
|
|
|
|
let current_origin_url = s:get_current_origin_url(a:bundle)
|
|
if current_origin_url != a:bundle.uri
|
|
call s:log('Plugin URI change detected for Plugin ' . a:bundle.name)
|
|
call s:log('> Plugin ' . a:bundle.name . ' old URI: ' . current_origin_url)
|
|
call s:log('> Plugin ' . a:bundle.name . ' new URI: ' . a:bundle.uri)
|
|
" Directory names match but the origin remotes are not the same
|
|
let cmd_parts = [
|
|
\ 'cd '.vundle#installer#shellesc(a:bundle.path()) ,
|
|
\ 'git remote set-url origin ' . vundle#installer#shellesc(a:bundle.uri),
|
|
\ 'git fetch',
|
|
\ 'git reset --hard origin/HEAD',
|
|
\ 'git submodule update --init --recursive',
|
|
\ ]
|
|
let cmd = join(cmd_parts, ' && ')
|
|
let cmd = vundle#installer#shellesc_cd(cmd)
|
|
let initial_sha = ''
|
|
return [cmd, initial_sha]
|
|
endif
|
|
|
|
if !(a:bang)
|
|
" The repo exists, and no !, so leave as it is.
|
|
return ['', '']
|
|
endif
|
|
|
|
let cmd_parts = [
|
|
\ 'cd '.vundle#installer#shellesc(a:bundle.path()),
|
|
\ 'git pull',
|
|
\ 'git submodule update --init --recursive',
|
|
\ ]
|
|
let cmd = join(cmd_parts, ' && ')
|
|
let cmd = vundle#installer#shellesc_cd(cmd)
|
|
|
|
let initial_sha = s:get_current_sha(a:bundle)
|
|
else
|
|
let cmd = 'git clone --recursive '.vundle#installer#shellesc(a:bundle.uri).' '.vundle#installer#shellesc(a:bundle.path())
|
|
let initial_sha = ''
|
|
endif
|
|
return [cmd, initial_sha]
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Install or update a given bundle object with git.
|
|
"
|
|
" bang -- 0 if only new plugins should be installed, 1 if existing plugins
|
|
" should be updated
|
|
" bundle -- a bundle object (dictionary)
|
|
" return -- a string indicating the status of the bundle installation:
|
|
" - todate : Nothing was updated or the repository was up to date
|
|
" - new : The plugin was newly installed
|
|
" - updated : Some changes where pulled via git
|
|
" - error : An error occurred in the shell command
|
|
" - pinned : The bundle is marked as pinned
|
|
" ---------------------------------------------------------------------------
|
|
func! s:sync(bang, bundle) abort
|
|
" Do not sync if this bundle is pinned
|
|
if a:bundle.is_pinned()
|
|
return 'pinned'
|
|
endif
|
|
|
|
let [ cmd, initial_sha ] = s:make_sync_command(a:bang, a:bundle)
|
|
if empty(cmd)
|
|
return 'todate'
|
|
endif
|
|
|
|
let out = s:system(cmd)
|
|
call s:log('')
|
|
call s:log('Plugin '.a:bundle.name_spec)
|
|
call s:log(cmd, '$ ')
|
|
call s:log(out, '> ')
|
|
|
|
if 0 != v:shell_error
|
|
return 'error'
|
|
end
|
|
|
|
if empty(initial_sha)
|
|
return 'new'
|
|
endif
|
|
|
|
let updated_sha = s:get_current_sha(a:bundle)
|
|
|
|
if initial_sha == updated_sha
|
|
return 'todate'
|
|
endif
|
|
|
|
call add(g:vundle#updated_bundles, [initial_sha, updated_sha, a:bundle])
|
|
return 'updated'
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Escape special characters in a string to be able to use it as a shell
|
|
" command with system().
|
|
"
|
|
" cmd -- the string holding the shell command
|
|
" return -- a string with the relevant characters escaped
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#shellesc(cmd) abort
|
|
if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh')))
|
|
return '"' . substitute(a:cmd, '"', '\\"', 'g') . '"'
|
|
endif
|
|
return shellescape(a:cmd)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Fix a cd shell command to be used on Windows.
|
|
"
|
|
" cmd -- the command to be fixed (string)
|
|
" return -- the fixed command (string)
|
|
" ---------------------------------------------------------------------------
|
|
func! vundle#installer#shellesc_cd(cmd) abort
|
|
if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh')))
|
|
let cmd = substitute(a:cmd, '^cd ','cd /d ','') " add /d switch to change drives
|
|
return cmd
|
|
else
|
|
return a:cmd
|
|
endif
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Make a system call. This can be used to change the way system calls
|
|
" are made during developing, without searching the whole code base for
|
|
" actual system() calls.
|
|
"
|
|
" cmd -- the command passed to system() (string)
|
|
" return -- the return value from system()
|
|
" ---------------------------------------------------------------------------
|
|
func! s:system(cmd) abort
|
|
return system(a:cmd)
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Add a log message to Vundle's internal logging variable.
|
|
"
|
|
" str -- the log message (string)
|
|
" prefix -- optional prefix for multi-line entries (string)
|
|
" return -- a:str
|
|
" ---------------------------------------------------------------------------
|
|
func! s:log(str, ...) abort
|
|
let prefix = a:0 > 0 ? a:1 : ''
|
|
let fmt = '%Y-%m-%d %H:%M:%S'
|
|
let lines = split(a:str, '\n', 1)
|
|
let time = strftime(fmt)
|
|
for line in lines
|
|
call add(g:vundle#log, '['. time .'] '. prefix . line)
|
|
endfor
|
|
return a:str
|
|
endf
|
|
|
|
|
|
" ---------------------------------------------------------------------------
|
|
" Remove leading and trailing whitespace from a string
|
|
"
|
|
" str -- The string to rid of trailing and leading spaces
|
|
" return -- A string stripped of side spaces
|
|
" ---------------------------------------------------------------------------
|
|
func! s:strip(str)
|
|
return substitute(a:str, '\%^\_s*\(.\{-}\)\_s*\%$', '\1', '')
|
|
endf
|
|
|
|
" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl:
|