diff options
Diffstat (limited to 'bundle/Vundle.vim/autoload')
| -rw-r--r-- | bundle/Vundle.vim/autoload/vundle.vim | 90 | ||||
| -rw-r--r-- | bundle/Vundle.vim/autoload/vundle/config.vim | 281 | ||||
| -rw-r--r-- | bundle/Vundle.vim/autoload/vundle/installer.vim | 547 | ||||
| -rw-r--r-- | bundle/Vundle.vim/autoload/vundle/scripts.vim | 270 |
4 files changed, 1188 insertions, 0 deletions
diff --git a/bundle/Vundle.vim/autoload/vundle.vim b/bundle/Vundle.vim/autoload/vundle.vim new file mode 100644 index 0000000..e458618 --- /dev/null +++ b/bundle/Vundle.vim/autoload/vundle.vim @@ -0,0 +1,90 @@ +" Vundle is a shortcut for Vim Bundle and Is a simple plugin manager for Vim +" Author: gmarik +" HomePage: http://github.com/gmarik/Vundle.vim +" Readme: http://github.com/gmarik/Vundle.vim/blob/master/README.md +" Version: 0.10.2 + +" Plugin Commands +com! -nargs=+ -bar Plugin +\ call vundle#config#bundle(<args>) + +com! -nargs=* -bang -complete=custom,vundle#scripts#complete PluginInstall +\ call vundle#installer#new('!' == '<bang>', <f-args>) + +com! -nargs=? -bang -complete=custom,vundle#scripts#complete PluginSearch +\ call vundle#scripts#all('!' == '<bang>', <q-args>) + +com! -nargs=0 -bang PluginList +\ call vundle#installer#list('!' == '<bang>') + +com! -nargs=? -bang PluginClean +\ call vundle#installer#clean('!' == '<bang>') + +com! -nargs=0 PluginDocs +\ call vundle#installer#helptags(g:vundle#bundles) + +" Aliases +com! -nargs=* -complete=custom,vundle#scripts#complete PluginUpdate PluginInstall! <args> + +" Vundle Aliases +com! -nargs=? -bang -complete=custom,vundle#scripts#complete VundleInstall PluginInstall<bang> <args> +com! -nargs=? -bang -complete=custom,vundle#scripts#complete VundleSearch PluginSearch<bang> <args> +com! -nargs=? -bang VundleClean PluginClean<bang> +com! -nargs=0 VundleDocs PluginDocs +com! VundleUpdate PluginInstall! +com! -nargs=* -complete=custom,vundle#scripts#complete VundleUpdate PluginInstall! <args> + +" Deprecated Commands +com! -nargs=+ Bundle call vundle#config#bundle(<args>) +com! -nargs=? -bang -complete=custom,vundle#scripts#complete BundleInstall PluginInstall<bang> <args> +com! -nargs=? -bang -complete=custom,vundle#scripts#complete BundleSearch PluginSearch<bang> <args> +com! -nargs=0 -bang BundleList PluginList<bang> +com! -nargs=? -bang BundleClean PluginClean<bang> +com! -nargs=0 BundleDocs PluginDocs +com! BundleUpdate PluginInstall! + +" Set up the signs used in the installer window. (See :help signs) +if (has('signs')) + sign define Vu_error text=! texthl=Error + sign define Vu_active text=> texthl=Comment + sign define Vu_todate text=. texthl=Comment + sign define Vu_new text=+ texthl=Comment + sign define Vu_updated text=* texthl=Comment + sign define Vu_deleted text=- texthl=Comment + sign define Vu_helptags text=* texthl=Comment + sign define Vu_pinned text== texthl=Comment +endif + +" Set up Vundle. This function has to be called from the users vimrc file. +" This will force Vim to source this file as a side effect which wil define +" the :Plugin command. After calling this function the user can use the +" :Plugin command in the vimrc. It is not possible to do this automatically +" because when loading the vimrc file no plugins where loaded yet. +func! vundle#rc(...) abort + if a:0 > 0 + let g:vundle#bundle_dir = expand(a:1, 1) + endif + call vundle#config#init() +endf + +" Alternative to vundle#rc, offers speed up by modifying rtp only when end() +" called later. +func! vundle#begin(...) abort + let g:vundle#lazy_load = 1 + call call('vundle#rc', a:000) +endf + +" Finishes putting plugins on the rtp. +func! vundle#end(...) abort + unlet g:vundle#lazy_load + call vundle#config#activate_bundles() +endf + +" Initialize some global variables used by Vundle. +let vundle#bundle_dir = expand('$HOME/.vim/bundle', 1) +let vundle#bundles = [] +let vundle#lazy_load = 0 +let vundle#log = [] +let vundle#updated_bundles = [] + +" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl: diff --git a/bundle/Vundle.vim/autoload/vundle/config.vim b/bundle/Vundle.vim/autoload/vundle/config.vim new file mode 100644 index 0000000..0e02b11 --- /dev/null +++ b/bundle/Vundle.vim/autoload/vundle/config.vim @@ -0,0 +1,281 @@ +" --------------------------------------------------------------------------- +" 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:vundle#bundles, bundle) + else + call s:rtp_rm_a() + call add(g:vundle#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:vundle#bundles') | let g:vundle#bundles = [] | endif + call s:rtp_rm_a() + let g:vundle#bundles = [] + let s: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:vundle#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:vundle#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(s:bundle_names, a:bundle.name) + echoerr 'Vundle error: Name collision for Plugin ' . a:bundle.name_spec . + \ '. Plugin ' . s:bundle_names[a:bundle.name] . + \ ' previously used the name "' . a:bundle.name . '"' . + \ '. Skipping Plugin ' . a:bundle.name_spec . '.' + return 0 + elseif a:bundle.name !~ '\v^[A-Za-z0-9_-]%(\.?[A-Za-z0-9_-])*$' + echoerr 'Invalid plugin name: ' . a:bundle.name + return 0 + endif + let s: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:vundle#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:vundle#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:vundle#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: diff --git a/bundle/Vundle.vim/autoload/vundle/installer.vim b/bundle/Vundle.vim/autoload/vundle/installer.vim new file mode 100644 index 0000000..472271a --- /dev/null +++ b/bundle/Vundle.vim/autoload/vundle/installer.vim @@ -0,0 +1,547 @@ +" --------------------------------------------------------------------------- +" 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: diff --git a/bundle/Vundle.vim/autoload/vundle/scripts.vim b/bundle/Vundle.vim/autoload/vundle/scripts.vim new file mode 100644 index 0000000..5d56476 --- /dev/null +++ b/bundle/Vundle.vim/autoload/vundle/scripts.vim @@ -0,0 +1,270 @@ +" --------------------------------------------------------------------------- +" Search the database from vim-script.org for a matching plugin. If no +" argument is given, list all plugins. This function is used by the :Plugins +" and :PluginSearch commands. +" +" bang -- if 1 refresh the script name cache, if 0 don't +" ... -- a plugin name to search for +" --------------------------------------------------------------------------- +func! vundle#scripts#all(bang, ...) + let b:match = '' + let info = ['"Keymap: i - Install plugin; c - Cleanup; s - Search; R - Reload list'] + let matches = s:load_scripts(a:bang) + if !empty(a:1) + let matches = filter(matches, 'v:val =~? "'.escape(a:1,'"').'"') + let info += ['"Search results for: '.a:1] + " TODO: highlight matches + let b:match = a:1 + endif + call vundle#scripts#view('search',info, vundle#scripts#bundle_names(reverse(matches))) + redraw + echo len(matches).' plugins found' +endf + + +" --------------------------------------------------------------------------- +" Repeat the search for bundles. +" --------------------------------------------------------------------------- +func! vundle#scripts#reload() abort + silent exec ':PluginSearch! '.(exists('b:match') ? b:match : '') + redraw +endf + + +" --------------------------------------------------------------------------- +" Complete names for bundles in the command line. +" +" a, c, d -- see :h command-completion-custom +" return -- all valid plugin names from vim-scripts.org as completion +" candidates, or all installed plugin names when running an 'Update +" variant'. see also :h command-completion-custom +" --------------------------------------------------------------------------- +func! vundle#scripts#complete(a,c,d) + if match(a:c, '\v^%(Plugin|Vundle)%(Install!|Update)') == 0 + " Only installed plugins if updating + return join(map(copy(g:vundle#bundles), 'v:val.name'), "\n") + else + " Or all known plugins otherwise + return join(s:load_scripts(0),"\n") + endif +endf + + +" --------------------------------------------------------------------------- +" View the logfile after an update or installation. +" --------------------------------------------------------------------------- +func! s:view_log() + if !exists('s:log_file') + let s:log_file = tempname() + endif + + if bufloaded(s:log_file) + execute 'silent bdelete' s:log_file + endif + call writefile(g:vundle#log, s:log_file) + execute 'silent pedit ' . s:log_file + + wincmd P | wincmd H +endf + + +" --------------------------------------------------------------------------- +" Parse the output from git log after an update to create a change log for the +" user. +" --------------------------------------------------------------------------- +func! s:create_changelog() abort + let changelog = ['Updated Plugins:'] + for bundle_data in g:vundle#updated_bundles + let initial_sha = bundle_data[0] + let updated_sha = bundle_data[1] + let bundle = bundle_data[2] + + let cmd = 'cd '.vundle#installer#shellesc(bundle.path()). + \ ' && git log --pretty=format:"%s %an, %ar" --graph '. + \ initial_sha.'..'.updated_sha + + let cmd = vundle#installer#shellesc_cd(cmd) + + let updates = system(cmd) + + call add(changelog, '') + call add(changelog, 'Updated Plugin: '.bundle.name) + + if bundle.uri =~ "https://github.com" + call add(changelog, 'Compare at: '.bundle.uri[0:-5].'/compare/'.initial_sha.'...'.updated_sha) + endif + + for update in split(updates, '\n') + let update = substitute(update, '\s\+$', '', '') + call add(changelog, ' '.update) + endfor + endfor + return changelog +endf + + +" --------------------------------------------------------------------------- +" View the change log after an update or installation. +" --------------------------------------------------------------------------- +func! s:view_changelog() + if !exists('s:changelog_file') + let s:changelog_file = tempname() + endif + + if bufloaded(s:changelog_file) + execute 'silent bdelete' s:changelog_file + endif + call writefile(s:create_changelog(), s:changelog_file) + execute 'silent pedit' s:changelog_file + + wincmd P | wincmd H +endf + + +" --------------------------------------------------------------------------- +" Create a list of 'Plugin ...' lines from a list of bundle names. +" +" names -- a list of names (strings) of plugins +" return -- a list of 'Plugin ...' lines suitable to be written to a buffer +" --------------------------------------------------------------------------- +func! vundle#scripts#bundle_names(names) + return map(copy(a:names), ' printf("Plugin ' ."'%s'".'", v:val) ') +endf + + +" --------------------------------------------------------------------------- +" Open a buffer to display information to the user. Several special commands +" are defined in the new buffer. +" +" title -- a title for the new buffer +" headers -- a list of header lines to be displayed at the top of the buffer +" results -- the main information to be displayed in the buffer (list of +" strings) +" --------------------------------------------------------------------------- +func! vundle#scripts#view(title, headers, results) + if exists('s:view') && bufloaded(s:view) + exec s:view.'bd!' + endif + + exec 'silent pedit [Vundle] '.a:title + + wincmd P | wincmd H + + let s:view = bufnr('%') + " + " make buffer modifiable + " to append without errors + set modifiable + + call append(0, a:headers + a:results) + + setl buftype=nofile + setl noswapfile + + setl cursorline + setl nonu ro noma + if (exists('&relativenumber')) | setl norelativenumber | endif + + setl ft=vundle + setl syntax=vim + syn keyword vimCommand Plugin + syn keyword vimCommand Bundle + syn keyword vimCommand Helptags + + com! -buffer -bang -nargs=1 DeletePlugin + \ call vundle#installer#run('vundle#installer#delete', split(<q-args>,',')[0], ['!' == '<bang>', <args>]) + + com! -buffer -bang -nargs=? InstallAndRequirePlugin + \ call vundle#installer#run('vundle#installer#install_and_require', split(<q-args>,',')[0], ['!' == '<bang>', <q-args>]) + + com! -buffer -bang -nargs=? InstallPlugin + \ call vundle#installer#run('vundle#installer#install', split(<q-args>,',')[0], ['!' == '<bang>', <q-args>]) + + com! -buffer -bang -nargs=0 InstallHelptags + \ call vundle#installer#run('vundle#installer#docs', 'helptags', []) + + com! -buffer -nargs=0 VundleLog call s:view_log() + + com! -buffer -nargs=0 VundleChangelog call s:view_changelog() + + nnoremap <buffer> q :silent bd!<CR> + nnoremap <buffer> D :exec 'Delete'.getline('.')<CR> + + nnoremap <buffer> add :exec 'Install'.getline('.')<CR> + nnoremap <buffer> add! :exec 'Install'.substitute(getline('.'), '^Plugin ', 'Plugin! ', '')<CR> + + nnoremap <buffer> i :exec 'InstallAndRequire'.getline('.')<CR> + nnoremap <buffer> I :exec 'InstallAndRequire'.substitute(getline('.'), '^Plugin ', 'Plugin! ', '')<CR> + + nnoremap <buffer> l :VundleLog<CR> + nnoremap <buffer> u :VundleChangelog<CR> + nnoremap <buffer> h :h vundle<CR> + nnoremap <buffer> ? :norm h<CR> + + nnoremap <buffer> c :PluginClean<CR> + nnoremap <buffer> C :PluginClean!<CR> + + nnoremap <buffer> s :PluginSearch + nnoremap <buffer> R :call vundle#scripts#reload()<CR> + + " goto first line after headers + exec ':'.(len(a:headers) + 1) +endf + + +" --------------------------------------------------------------------------- +" Load the plugin database from vim-scripts.org . +" +" to -- the filename (string) to save the database to +" return -- 0 on success, 1 if an error occurred +" --------------------------------------------------------------------------- +func! s:fetch_scripts(to) + let scripts_dir = fnamemodify(expand(a:to, 1), ":h") + if !isdirectory(scripts_dir) + call mkdir(scripts_dir, "p") + endif + + let l:vim_scripts_json = 'http://vim-scripts.org/api/scripts.json' + if executable("curl") + let cmd = 'curl --fail -s -o '.vundle#installer#shellesc(a:to).' '.l:vim_scripts_json + elseif executable("wget") + let temp = vundle#installer#shellesc(tempname()) + let cmd = 'wget -q -O '.temp.' '.l:vim_scripts_json. ' && mv -f '.temp.' '.vundle#installer#shellesc(a:to) + if (has('win32') || has('win64')) + let cmd = substitute(cmd, 'mv -f ', 'move /Y ', '') " change force flag + let cmd = vundle#installer#shellesc(cmd) + end + else + echoerr 'Error curl or wget is not available!' + return 1 + endif + + call system(cmd) + + if (0 != v:shell_error) + echoerr 'Error fetching scripts!' + return v:shell_error + endif + return 0 +endf + + +" --------------------------------------------------------------------------- +" Load the plugin database and return a list of all plugins. +" +" bang -- if 1 download the redatabase, else only download if it is not +" readable on disk (i.e. does not exist) +" return -- a list of strings, these are the names (valid bundle +" specifications) of all plugins from vim-scripts.org +" --------------------------------------------------------------------------- +func! s:load_scripts(bang) + let f = expand(g:vundle#bundle_dir.'/.vundle/script-names.vim-scripts.org.json', 1) + if a:bang || !filereadable(f) + if 0 != s:fetch_scripts(f) + return [] + end + endif + return eval(readfile(f, 'b')[0]) +endf + +" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl: |