aboutsummaryrefslogtreecommitdiff
path: root/bundle/Vundle.vim/autoload/vundle
diff options
context:
space:
mode:
authorCody Hiar <codyfh@gmail.com>2015-08-17 11:57:49 -0600
committerCody Hiar <codyfh@gmail.com>2015-08-17 11:57:49 -0600
commite398816da47aa706b2bf05b8a663a637d5b6f39c (patch)
tree6231dd8617d79e4dc2192ace65e14ba8fb66ca1e /bundle/Vundle.vim/autoload/vundle
parent547be64dd10d56c1a0979756eaf0b2aaaf15f6ec (diff)
Changing to different plugin system
Diffstat (limited to 'bundle/Vundle.vim/autoload/vundle')
-rw-r--r--bundle/Vundle.vim/autoload/vundle/config.vim281
-rw-r--r--bundle/Vundle.vim/autoload/vundle/installer.vim547
-rw-r--r--bundle/Vundle.vim/autoload/vundle/scripts.vim270
3 files changed, 0 insertions, 1098 deletions
diff --git a/bundle/Vundle.vim/autoload/vundle/config.vim b/bundle/Vundle.vim/autoload/vundle/config.vim
deleted file mode 100644
index 0e02b11..0000000
--- a/bundle/Vundle.vim/autoload/vundle/config.vim
+++ /dev/null
@@ -1,281 +0,0 @@
-" ---------------------------------------------------------------------------
-" 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
deleted file mode 100644
index 472271a..0000000
--- a/bundle/Vundle.vim/autoload/vundle/installer.vim
+++ /dev/null
@@ -1,547 +0,0 @@
-" ---------------------------------------------------------------------------
-" 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
deleted file mode 100644
index 5d56476..0000000
--- a/bundle/Vundle.vim/autoload/vundle/scripts.vim
+++ /dev/null
@@ -1,270 +0,0 @@
-" ---------------------------------------------------------------------------
-" 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: