barak/dotfiles
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

switch to neobundle

Browse source
This commit is contained in:
Barak Michener 2016-10-27 13:40:04 -07:00
parent 6cef5c101f
commit 5a1c95140f
57 changed files with 9901 additions and 1958 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.vim/bundle/Vundle.vim/.gitignore vendored
View file

@ -1,2 +0,0 @@
doc/tags
.netrwhist

111
.vim/bundle/Vundle.vim/CONTRIBUTING.md
View file

@ -1,111 +0,0 @@
Pull Requests
=============
1. Please squash your commits to minimize the log pollution. This is more of a convenience for the maintainer who pulls. If you are unfamiliar, see [here](http://ariejan.net/2011/07/05/git-squash-your-latests-commits-into-one/).
2. Clearly describe what you aim to fix or add to Vundle.
3. Try to minimize code changes and use existing style/functions.
Issues
======
## Check For Answers
Before submitting an issue, be sure to check the following places for answers.
1. Vundle docs at [`:h vundle`](https://github.com/gmarik/Vundle.vim/blob/master/doc/vundle.txt).
2. The [FAQ](https://github.com/gmarik/Vundle.vim/search).
3. [Search](https://github.com/gmarik/Vundle.vim/search) the repository for related issues.
## Try To Eliminate Your Vimrc
In order to make sure it isn't just `.vimrc` replace your own config file with the [minimal vimrc](https://github.com/gmarik/Vundle.vim/blob/master/test/minirc.vim). Clear out bundles and then try to reproduce.
If the problem stops, likely there is an issue in your user configuration. You can incrementally add back your user changes to the minimal file testing the bug each time. This will allow you to slowly bisect the issue. You may want to test one plugin at a time.
If you can still reproduce the problem, try to find the smallest `.vimrc` config file that creates the problem to include later.
## Guidelines
To better respond to issues please follow these general guidelines when explaining the problem.
1. Clearly describe what the error is, if relevant attach output/screenshots.
2. Describe how developers can reproduce the bug, the steps should be from starting Vim.
3. Include your OS, version and architecture. For example, Windows 7 64, Kubuntu 13.04 32, etc...
4. If relevant to reproducing the bug, include the smallest subset of your `.vimrc` that causes the issue. Put this in code tags.
5. At the end of your issue, please put the output of `vim --version` in code tags.
## Example Post
I am using Vim on Kubuntu 13.04 64 bit and I get the following error... (add further explanation here)
To reproduce the bug, use the vimrc file below and run `:BundleInstall`... (continue with steps)
Vimrc:
```
set nocompatible
syntax on
filetype off
set rtp+=~/.vim/bundle/Vundle.vim/
call vundle#rc()
Bundle 'gmarik/Vundle.vim'
Bundle 'relevant/plugin'
filetype plugin indent on
.... more user configs here...
```
Vim Version:
```
VIM - Vi IMproved 7.4 (2013 Aug 10, compiled Aug 15 2013 10:58:39)
Included patches: 1-5
Modified by pkg-vim-maintainers@lists.alioth.debian.org
Compiled by buildd@
Huge version with GTK2 GUI. Features included (+) or not (-):
+arabic +file_in_path +mouse_sgr +tag_binary
+autocmd +find_in_path -mouse_sysmouse +tag_old_static
+balloon_eval +float +mouse_urxvt -tag_any_white
+browse +folding +mouse_xterm +tcl
++builtin_terms -footer +multi_byte +terminfo
+byte_offset +fork() +multi_lang +termresponse
+cindent +gettext -mzscheme +textobjects
+clientserver -hangul_input +netbeans_intg +title
+clipboard +iconv +path_extra +toolbar
+cmdline_compl +insert_expand +perl +user_commands
+cmdline_hist +jumplist +persistent_undo +vertsplit
+cmdline_info +keymap +postscript +virtualedit
+comments +langmap +printer +visual
+conceal +libcall +profile +visualextra
+cryptv +linebreak +python +viminfo
+cscope +lispindent -python3 +vreplace
+cursorbind +listcmds +quickfix +wildignore
+cursorshape +localmap +reltime +wildmenu
+dialog_con_gui +lua +rightleft +windows
+diff +menu +ruby +writebackup
+digraphs +mksession +scrollbind +X11
+dnd +modify_fname +signs -xfontset
-ebcdic +mouse +smartindent +xim
+emacs_tags +mouseshape -sniff +xsmp_interact
+eval +mouse_dec +startuptime +xterm_clipboard
+ex_extra +mouse_gpm +statusline -xterm_save
+extra_search -mouse_jsbterm -sun_workshop
+farsi +mouse_netterm +syntax
system vimrc file: "$VIM/vimrc"
user vimrc file: "$HOME/.vimrc"
2nd user vimrc file: "~/.vim/vimrc"
user exrc file: "$HOME/.exrc"
system gvimrc file: "$VIM/gvimrc"
user gvimrc file: "$HOME/.gvimrc"
2nd user gvimrc file: "~/.vim/gvimrc"
system menu file: "$VIMRUNTIME/menu.vim"
fall-back for $VIM: "/usr/share/vim"
Compilation: gcc -c -I. -Iproto -DHAVE_CONFIG_H -DFEAT_GUI_GTK -pthread -I/usr/include/gtk-2.0 -I/usr/lib/x86_64-linux-gnu/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/pango-1.0 -I/usr/include/gio-unix-2.0/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng12 -I/usr/include/harfbuzz -g -O2 -fstack-protector --param=ssp-buffer-size=4 -Wformat -Werror=format-security -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1 -I/usr/include/tcl8.5 -D_REENTRANT=1 -D_THREAD_SAFE=1 -D_LARGEFILE64_SOURCE=1
Linking: gcc -L. -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic -Wl,-E -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,--as-needed -o vim -lgtk-x11-2.0 -lgdk-x11-2.0 -latk-1.0 -lgio-2.0 -lpangoft2-1.0 -lpangocairo-1.0 -lgdk_pixbuf-2.0 -lcairo -lpango-1.0 -lfreetype -lfontconfig -lgobject-2.0 -lglib-2.0 -lSM -lICE -lXpm -lXt -lX11 -lXdmcp -lSM -lICE -lm -ltinfo -lnsl -lselinux -lacl -lattr -lgpm -ldl -L/usr/lib -llua5.1 -Wl,-E -fstack-protector -L/usr/local/lib -L/usr/lib/perl/5.14/CORE -lperl -ldl -lm -lpthread -lcrypt -L/usr/lib/python2.7/config-x86_64-linux-gnu -lpython2.7 -lpthread -ldl -lutil -lm -Xlinker -export-dynamic -Wl,-O1 -Wl,-Bsymbolic-functions -L/usr/lib/x86_64-linux-gnu -ltcl8.5 -ldl -lpthread -lieee -lm -lruby-1.9.1 -lpthread -lrt -ldl -lcrypt -lm -L/usr/lib
```

158
.vim/bundle/Vundle.vim/README.md
View file

@ -1,158 +0,0 @@
## [Help Maintain Vundle](https://github.com/gmarik/Vundle.vim/issues/383)
## About
[Vundle] is short for _Vim bundle_ and is a [Vim] plugin manager.
[Vundle] allows you to...
* keep track of and [configure] your plugins right in the `.vimrc`
* [install] configured plugins (a.k.a. scripts/bundle)
* [update] configured plugins
* [search] by name all available [Vim scripts]
* [clean] unused plugins up
* run the above actions in a *single keypress* with [interactive mode]
[Vundle] automatically...
* manages the [runtime path] of your installed scripts
* regenerates [help tags] after installing and updating
[Vundle] is undergoing an [interface change], please stay up to date to get latest changes.
[![Gitter-chat](https://badges.gitter.im/gmarik/Vundle.vim.png)](https://gitter.im/gmarik/Vundle.vim) for discussion and support.
![Vundle-installer](http://i.imgur.com/Rueh7Cc.png)
## Quick Start
1. Introduction:
Installation requires [Git] and triggers [`git clone`] for each configured repository to `~/.vim/bundle/` by default.
Curl is required for search.
If you are using Windows, go directly to [Windows setup]. If you run into any issues, please consult the [FAQ].
See [Tips] for some advanced configurations.
2. Set up [Vundle]:
`$ git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim`
3. Configure Plugins:
Put this at the top of your `.vimrc` to use Vundle. Remove plugins you don't need, they are for illustration purposes.
```vim
set nocompatible " be iMproved, required
filetype off " required
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" alternatively, pass a path where Vundle should install plugins
"call vundle#begin('~/some/path/here')
" let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'
" The following are examples of different formats supported.
" Keep Plugin commands between vundle#begin/end.
" plugin on GitHub repo
Plugin 'tpope/vim-fugitive'
" plugin from http://vim-scripts.org/vim/scripts.html
Plugin 'L9'
" Git plugin not hosted on GitHub
Plugin 'git://git.wincent.com/command-t.git'
" git repos on your local machine (i.e. when working on your own plugin)
Plugin 'file:///home/gmarik/path/to/plugin'
" The sparkup vim script is in a subdirectory of this repo called vim.
" Pass the path to set the runtimepath properly.
Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
" Avoid a name conflict with L9
Plugin 'user/L9', {'name': 'newL9'}
" All of your Plugins must be added before the following line
call vundle#end() " required
filetype plugin indent on " required
" To ignore plugin indent changes, instead use:
"filetype plugin on
"
" Brief help
" :PluginList - list configured plugins
" :PluginInstall(!) - install (update) plugins
" :PluginSearch(!) foo - search (or refresh cache first) for foo
" :PluginClean(!) - confirm (or auto-approve) removal of unused plugins
"
" see :h vundle for more details or wiki for FAQ
" Put your non-Plugin stuff after this line
```
4. Install Plugins:
Launch `vim` and run `:PluginInstall`
To install from command line: `vim +PluginInstall +qall`
## Docs
See the [`:h vundle`](https://github.com/gmarik/Vundle.vim/blob/master/doc/vundle.txt) Vimdoc for more details.
## Changelog
See the [changelog](https://github.com/gmarik/Vundle.vim/blob/master/changelog.md).
## People Using Vundle
see [Examples](https://github.com/gmarik/Vundle.vim/wiki/Examples)
## Contributors
see [Vundle contributors](https://github.com/gmarik/Vundle.vim/graphs/contributors)
*Thank you!*
## Inspiration & Ideas
* [pathogen.vim](http://github.com/tpope/vim-pathogen/)
* [Bundler](https://github.com/bundler/bundler)
* [Scott Bronson](http://github.com/bronson)
## Also
* Vundle was developed and tested with [Vim] 7.3 on OS X, Linux and Windows
* Vundle tries to be as [KISS](http://en.wikipedia.org/wiki/KISS_principle) as possible
## TODO:
[Vundle] is a work in progress, so any ideas and patches are appreciated.
* ✓ activate newly added bundles on `.vimrc` reload or after `:PluginInstall`
* ✓ use preview window for search results
* ✓ Vim documentation
* ✓ put Vundle in `bundles/` too (will fix Vundle help)
* ✓ tests
* ✓ improve error handling
* allow specifying revision/version?
* handle dependencies
* show description in search results
* search by description as well
* make it rock!
[Vundle]:http://github.com/gmarik/Vundle.vim
[Windows setup]:https://github.com/gmarik/Vundle.vim/wiki/Vundle-for-Windows
[FAQ]:https://github.com/gmarik/Vundle.vim/wiki
[Tips]:https://github.com/gmarik/Vundle.vim/wiki/Tips-and-Tricks
[Vim]:http://www.vim.org
[Git]:http://git-scm.com
[`git clone`]:http://gitref.org/creating/#clone
[Vim scripts]:http://vim-scripts.org/vim/scripts.html
[help tags]:http://vimdoc.sourceforge.net/htmldoc/helphelp.html#:helptags
[runtime path]:http://vimdoc.sourceforge.net/htmldoc/options.html#%27runtimepath%27
[configure]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L126-L233
[install]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L234-L254
[update]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L255-L265
[search]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L266-L295
[clean]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L303-L318
[interactive mode]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L319-L360
[interface change]:https://github.com/gmarik/Vundle.vim/blob/v0.10.2/doc/vundle.txt#L372-L396

83
.vim/bundle/Vundle.vim/autoload/vundle.vim
View file

@ -1,83 +0,0 @@
" 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>', <q-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:bundles)
" Aliases
com! PluginUpdate PluginInstall!
" 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!
" 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
let g:bundle_dir = len(a:000) > 0 ? expand(a:1, 1) : expand('$HOME/.vim/bundle', 1)
let g:updated_bundles = []
let g:vundle_log = []
let g:vundle_changelog = ['Updated Plugins:']
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
" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl:

278
.vim/bundle/Vundle.vim/autoload/vundle/config.vim
View file

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

534
.vim/bundle/Vundle.vim/autoload/vundle/installer.vim
View file

File diff suppressed because it is too large Load diff

257
.vim/bundle/Vundle.vim/autoload/vundle/scripts.vim
View file

@ -1,257 +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, see also :h command-completion-custom
" ---------------------------------------------------------------------------
func! vundle#scripts#complete(a,c,d)
return join(s:load_scripts(0),"\n")
endf
" ---------------------------------------------------------------------------
" View the logfile after an update or installation.
" ---------------------------------------------------------------------------
func! s:view_log()
if !exists('g:vundle_log_file')
let g:vundle_log_file = tempname()
endif
call writefile(g:vundle_log, g:vundle_log_file)
execute 'silent pedit ' . g:vundle_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
for bundle_data in g: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(g:vundle_changelog, '')
call add(g:vundle_changelog, 'Updated Plugin: '.bundle.name)
if bundle.uri =~ "https://github.com"
call add(g:vundle_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(g:vundle_changelog, ' '.update)
endfor
endfor
endf
" ---------------------------------------------------------------------------
" View the change log after an update or installation.
" ---------------------------------------------------------------------------
func! s:view_changelog()
call s:create_changelog()
if !exists('g:vundle_changelog_file')
let g:vundle_changelog_file = tempname()
endif
call writefile(g:vundle_changelog, g:vundle_changelog_file)
execute 'silent pedit ' . g:vundle_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('g:vundle_view') && bufloaded(g:vundle_view)
exec g:vundle_view.'bd!'
endif
exec 'silent pedit [Vundle] '.a:title
wincmd P | wincmd H
let g:vundle_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: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:

22
.vim/bundle/Vundle.vim/changelog.md
View file

@ -1,22 +0,0 @@
Change Log
==========
F = Feature, B = Bug Fix, D = Doc Change
### Version 0.10.2
- B: #430 Put user script directories before system directories in rtp
- B: #455 Rename functions that start with `g:` + lowercase letter (Vim patch 7.4.264)
### Version 0.10.1
- B: #451 Escape spaces when handling rtp directories
### Version 0.10
- F: #415 Support plugin pinning (for non-git repos & preventing updates)
- F: #440 Detect plugin name collisions
- F: #418 Deferred rtp manipulation (speeds up start)
- B: #418 Leave default rtp directories (i.e. ~/.vim) where they should be
- B: #429 Fix newline character in log
- B: #440 Detect changed remotes & update repos
- D: #435 Image update in README.md
- D: #419 Add function documentation
- D: #436 Rename vundle to Vundle.vim, add modelines, quickstart update

397
.vim/bundle/Vundle.vim/doc/vundle.txt
View file

@ -1,397 +0,0 @@
*vundle.txt* Vundle, a plug-in manager for Vim. *vundle*
VUNDLE MANUAL
1. About Vundle |vundle-about|
2. Quick Start |vundle-quickstart|
3. Plugins |vundle-plugins|
3.1. Configuring Plugins |vundle-plugins-configure|
3.2. Supported URIs |vundle-plugins-uris|
3.3. Installing Plugins |vundle-plugins-install|
3.4. Updating Plugins |vundle-plugins-update|
3.5. Searching Plugins |vundle-plugins-search|
3.6. Listing Plugins |vundle-plugins-list|
3.7. Cleaning Up |vundle-plugins-cleanup|
4. Interactive Mode |vundle-interactive|
5. Key Mappings |vundle-keymappings|
6. Options |vundle-options|
7. Plugin Interface Change |vundle-interface-change|
=============================================================================
1. ABOUT VUNDLE ~
*vundle-about*
Vundle is short for Vim bundle and is a Vim plugin manager.
Vundle allows you to...
- keep track of and configure your scripts right in the `.vimrc`
- install configured scripts (a.k.a. bundle)
- update configured scripts
- search by name all available Vim scripts
- clean unused scripts up
- run the above actions in a single keypress with interactive mode
Vundle automatically...
- manages the runtime path of your installed scripts
- regenerates help tags after installing and updating
Vundle's search uses http://vim-scripts.org to provide a list of all
available Vim scripts.
Vundle is undergoing an interface change, see |vundle-interface-change| for
more information.
=============================================================================
2. QUICK START ~
*vundle-quickstart*
1. Introduction:
Installation requires `Git` and triggers git clone for each configured
repository to `~/.vim/bundle/` by default. Curl is required for search.
*vundle-windows*
If you are using Windows, see instructions on the Wiki
https://github.com/gmarik/Vundle.vim/wiki/Vundle-for-Windows.
*vundle-faq*
If you run into any issues, please consult the FAQ at
https://github.com/gmarik/Vundle.vim/wiki
2. Setup Vundle:
>
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim
<
3. Configure bundles:
Put this at the top of your `.vimrc` to use Vundle. Remove bundles you
don't need, they are for illustration purposes.
>
set nocompatible " be iMproved, required
filetype off " required
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" alternatively, pass a path where Vundle should install plugins
"call vundle#begin('~/some/path/here')
" let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'
" The following are examples of different formats supported.
" Keep Plugin commands between vundle#begin/end.
" plugin on GitHub repo
Plugin 'tpope/vim-fugitive'
" plugin from http://vim-scripts.org/vim/scripts.html
Plugin 'L9'
" Git plugin not hosted on GitHub
Plugin 'git://git.wincent.com/command-t.git'
" git repos on your local machine (i.e. when working on your own plugin)
Plugin 'file:///home/gmarik/path/to/plugin'
" The sparkup vim script is in a subdirectory of this repo called vim.
" Pass the path to set the runtimepath properly.
Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
" Avoid a name conflict with L9
Plugin 'user/L9', {'name': 'newL9'}
" All of your Plugins must be added before the following line
call vundle#end() " required
filetype plugin indent on " required
" To ignore plugin indent changes, instead use:
"filetype plugin on
"
" Brief help
" :PluginList - list configured plugins
" :PluginInstall(!) - install (update) plugins
" :PluginSearch(!) foo - search (or refresh cache first) for foo
" :PluginClean(!) - confirm (or auto-approve) removal of unused plugins
"
" see :h vundle for more details or wiki for FAQ
" Put your non-Plugin stuff after this line
4. Install configured bundles:
Launch vim and run
>
:PluginInstall
<
To install from command line:
>
vim +PluginInstall +qall
=============================================================================
3. PLUGINS ~
*vundle-plugins*
3.1 CONFIGURING PLUGINS ~
*vundle-plugins-configure* *:Plugin*
Vundle tracks what plugins you want configured by the `Plugin` commands in your
`.vimrc`. Each `Plugin` command tells Vundle to activate the script on startup
adding it to your |runtimepath|. Commenting out or removing the line will
disable the `Plugin`.
Each `Plugin` command takes a URI pointing to the script. No comments should
follow on the same line as the command. Example:
>
Plugin 'git_URI'
The `Plugin` command can optionally take a second argument after the URI. It
has to be a dictionary, separated from the URI by a comma. Each key-value pair
in the dictionary is a configuration option.
The following per-script configuration options are available.
The 'rtp' option
----------------
Specifies a directory inside the repository (relative path from the root of
the repository) where the vim plugin resides. It determines the path that will
be added to the |runtimepath|.
For example:
>
Plugin 'git_URI', {'rtp': 'some/subdir/'}
This can be used with git repositories that put the vim plugin inside a
subdirectory.
The 'name' option
-----------------
The name of the directory that will hold the local clone of the configured
script.
For example:
>
Plugin 'git_URI', {'name': 'newPluginName'}
This can be used to prevent name collisions between plugins that Vundle would
otherwise try to clone into the same directory. It also provides an additional
level of customisation.
The 'pinned' option
-------------------
A flag that, when set to a value of 1, tells Vundle not to perform any git
operations on the plugin, while still adding the existing plugin under the
`bundles` directories to the |runtimepath|.
For example:
>
Plugin 'mylocalplugin', {'pinned': 1}
This allows the users to include, with Vundle, plugins tracked with version
control systems other than git, but the user is responsible for cloning and
keeping up to date. It also allows the users to stay in the current version of
a plugin that might have previously been updated by Vundle.
Please note that the URI will be treated the same as for any other plugins, so
only the last part of it will be added to the |runtimepath|. The user is
advised to use this flag only with single word URIs to avoid confusion.
3.2 SUPPORTED URIS ~
*vundle-plugins-uris*
`Vundle` integrates very well with both GitHub and vim-scripts.org
(http://vim-scripts.org/vim/scripts.html) allowing short URIs. It also allows
the use of any URI `git` recognizes. In all of the following cases (except
local) the 'https' protocol is used, see Vundle's options to override this.
More information on `git`'s protocols can be found at:
http://git-scm.com/book/ch4-1.html
GitHub
------
GitHub is used when a user/repo is passed to `Plugin`.
>
Plugin 'gmarik/Vundle.vim' => https://github.com/gmarik/Vundle.vim
Vim Scripts
-----------
Any single word without a slash '/' is assumed to be from Vim Scripts.
>
Plugin 'ctrlp.vim' => https://github.com/vim-scripts/ctrlp.vim
Other Git URIs
--------------
No modification is performed on valid URIs that point outside the above
URLs.
>
Plugin 'git://git.wincent.com/command-t.git'
Local Plugins
-------------
The git protocol supports local installation using the 'file://' protocol.
This is handy when developing plugins locally. Follow the protocol with an
absolute path to the script directory.
>
Plugin 'file:///path/from/root/to/plugin'
3.3 INSTALLING PLUGINS ~
*vundle-plugins-install* *:PluginInstall*
>
:PluginInstall
Will install all plugins configured in your `.vimrc`. Newly installed
plugins will be automatically enabled. Some plugins may require extra steps
such as compilation or external programs, refer to their documentation.
PluginInstall allows installation of plugins by name:
>
:PluginInstall unite.vim
Installs and activates unite.vim. You can use Tab to auto-complete known
script names. Note that the installation just described isn't permanent. To
finish, you must put `Plugin 'unite.vim'` at the appropriate place in your
`.vimrc` to tell Vundle to load the plugin at startup.
After installing plugins press 'l' (lowercase 'L') to see the log of commands
if any errors occurred.
3.4 UPDATING PLUGINS ~
*vundle-plugins-update* *:PluginUpdate* *:PluginInstall!*
>
:PluginInstall! " NOTE: bang(!)
or >
:PluginUpdate
Installs or updates the configured plugins. Press 'u' after updates complete
to see the change log of all updated bundles. Press 'l' (lowercase 'L') to
see the log of commands if any errors occurred.
3.5 SEARCHING PLUGINS ~
*vundle-plugins-search* *:PluginSearch*
>
:PluginSearch
Search requires that `curl` be available on the system. The command searches
Vim Scripts (http://vim-scripts.org/vim/scripts.html) for matching
plugins. Results display in a new split window. For example:
>
PluginSearch foo
displays:
>
"Search results for: foo
Plugin 'MarkdownFootnotes'
Plugin 'VimFootnotes'
Plugin 'foo.vim'
<
*:PluginSearch!*
Alternatively, you can refresh the script list before searching by adding a
bang to the command.
>
:PluginSearch! foo
If the command is run without argument:
>
:PluginSearch!
it will display all known plugins in the new split.
3.6 LISTING BUNDLES ~
*vundle-plugins-list* *:PluginList*
>
:PluginList
Displays a list of installed bundles.
3.7 CLEANING UP ~
*vundle-plugins-cleanup* *:PluginClean*
>
:PluginClean
Requests confirmation for the removal of all plugins no longered configured
in your `.vimrc` but present in your bundle installation directory
(default: `.vim/bundle/`).
*:PluginClean!*
>
:PluginClean!
Automatically confirm removal of unused bundles.
=============================================================================
4. INTERACTIVE MODE ~
*vundle-interactive*
Vundle provides a simple interactive mode to help you explore new plugins
easily. Interactive mode is available after any command that lists `Plugins`
such as PluginSearch, PluginList or Plugins. For instance:
>
:PluginSearch! unite
Searches for plugins matching 'unite' and yields a split window with:
>
"Keymap: i - Install bundle; c - Cleanup; s - Search; R - Reload list
"Search results for: unite
Plugin 'unite-scriptenames'
Plugin 'unite.vim'
Plugin 'unite-yarm'
Plugin 'unite-gem'
Plugin 'unite-locate'
Plugin 'unite-font'
Plugin 'unite-colorscheme'
To install a bundle, move your cursor to the Plugin of interest and then
select a command. To install 'unite.vim' put your cursor on the line and
then push `i`. For a more complete list see |vundle-keymappings|. After
unite.vim is installed the `:Unite file` command should be available.
Note: Interactive installation doesn't update your `.vimrc`.
=============================================================================
5. KEY MAPPINGS ~
*vundle-keymappings*
KEY | DESCRIPTION
----|-------------------------- >
i | run :PluginInstall with name taken from line cursor is positioned on
I | same as i, but runs :PluginInstall! to update bundle
D | delete selected bundle (be careful not to remove local modifications)
c | run :PluginClean
s | run :PluginSearch
R | fetch fresh script list from server
=============================================================================
6. OPTIONS ~
*vundle-options*
>
let g:vundle_default_git_proto = 'git'
<
This option makes Vundle use `git` instead of `https` when building
absolute URIs. For example:
>
Plugin 'sjl/gundo.vim' -> git@github.com:sjl/gundo.git
=============================================================================
7. VUNDLE INTERFACE CHANGE ~
*vundle-interface-change* *:Bundle* *:BundleInstall!*
*:BundleUpdate* *:BundleSearch* *:BundleList* *:BundleClean!*
*:VundleInstall!* *:VundleUpdate* *:VundleSearch*
*:VundleList* *:VundleClean!*
In order to bring in new changes, Vundle is adopting a new interface.
Going forward we will support primarily the Plugin namespace, additionally
for convenience we will also alias some commands to the Vundle namespace.
The following table summarizes the interface changes.
Deprecated Names | New Names
-----------------------------
Bundle | Plugin
BundleInstall(!) | PluginInstall(!), VundleInstall(!)
BundleUpdate | PluginUpdate, VundleUpdate
BundleSearch(!) | PluginSearch(!), VundleSearch(!)
BundleClean | PluginClean(!), VundleClean(!)
BundleList | PluginList
Note: The Bundle commands will be deprecated. You may continue using them,
but they may not get all future updates. For instance, we have enabled
comments on Plugin lines but not Bundle, since it requires a change in
command declaration.
" vim: set expandtab sts=2 ts=2 sw=2 tw=78 ft=help norl:

20
.vim/bundle/Vundle.vim/test/files/test.erl
View file

@ -1,20 +0,0 @@
-module(mmc_logmon_sup).
-behaviour(supervisor).
-export([init/1]).
init(_) ->
{ok, {
{one_for_one, 5, 1},
[
{listener,
{aaa, start_link, []},
permanent, 100, worker,
[aaa]
},
{server,
{bbb, start_link, []},
permanent, 100, worker,
[bbb]
}
]
}}.

8
.vim/bundle/Vundle.vim/test/minirc.vim
View file

@ -1,8 +0,0 @@
set nocompatible
syntax on
filetype off
set rtp+=~/.vim/bundle/Vundle.vim/
call vundle#rc()
Bundle 'gmarik/Vundle.vim'
filetype plugin indent on

81
.vim/bundle/Vundle.vim/test/vimrc
View file

@ -1,81 +0,0 @@
" vim -u test/vimrc
set nocompatible
set nowrap
let bundle_dir = '/tmp/vundle-test/bundles/'
" let src = 'http://github.com/gmarik/vundle.git'
" Vundle Options
" let g:vundle_default_git_proto = 'git'
silent execute '!mkdir -p '.bundle_dir
silent execute '!ln -f -s ~/.vim/bundle/Vundle.vim '.bundle_dir
filetype off
syntax on
runtime macros/matchit.vim
" This test should be executed in "test" directory
exec 'set rtp^='.bundle_dir.'Vundle.vim/'
call vundle#rc(bundle_dir)
Plugin 'molokai' " vim-scripts name
" github username with dashes
Bundle 'vim-scripts/ragtag.vim'
" original repo
Bundle 'altercation/vim-colors-solarized'
" with extension
Bundle 'nelstrom/vim-mac-classic-theme.git'
"
" invalid uri
"Bundle 'nonexistinguser/yupppierepo.git'
" full uri
Bundle 'https://github.com/vim-scripts/vim-game-of-life'
" full uri
Bundle 'git@github.com:gmarik/ingretu.git'
" short uri
Bundle 'gh:gmarik/snipmate.vim.git'
Bundle 'github:mattn/gist-vim.git'
" local uri stuff
Bundle '~/Dropbox/.gitrepos/utilz.vim.git'
" Bundle 'file://Dropbox/.gitrepos/utilz.vim.git'
" with options
Bundle 'rstacruz/sparkup.git', {'rtp': 'vim/'}
Bundle 'matchit.zip', {'name': 'matchit'}
" Camel case
Bundle 'vim-scripts/RubySinatra'
" syntax issue #203
Bundle 'jimenezrick/vimerl'
" Static bundle: Same name as a valid vim-scripts bundle
Bundle 'latte', {'pinned' : 1}
if !isdirectory(expand(bundle_dir) . '/latte')
call mkdir(expand(bundle_dir) . '/latte', 'p')
endif
filetype plugin indent on " Automatically detect file types.
set wildignore+=doc " should not break helptags
set wildignore+=.git " should not break clone
set wildignore+=.git/* " should not break clone
set wildignore+=*/.git/*
" TODO: helptags fails with this
" set wildignore+=doc/* " should not break clone
" set wildignore+=*/doc/*
au VimEnter * BundleInstall
" e test/files/erlang.erl
" vim: set expandtab sts=2 ts=2 sw=2 tw=78:

1
.vim/bundle/neobundle.vim/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
doc/tags

13
.vim/bundle/neobundle.vim/.travis.yml Normal file
View file

@ -0,0 +1,13 @@
language: viml
sudo: false
before_script:
- vim --version
- git clone https://github.com/syngan/vim-vimlint /tmp/vim-vimlint
- git clone https://github.com/ynkdir/vim-vimlparser /tmp/vim-vimlparser
- git clone https://github.com/thinca/vim-themis
script:
- sh /tmp/vim-vimlint/bin/vimlint.sh -l /tmp/vim-vimlint -p /tmp/vim-vimlparser -e EVL103=1 -e EVL102.l:_=1 autoload
- make test

0
.vim/bundle/Vundle.vim/LICENSE-MIT.txt → .vim/bundle/neobundle.vim/LICENSE-MIT.txt
View file

15
.vim/bundle/neobundle.vim/Makefile Normal file
View file

@ -0,0 +1,15 @@
test: vim-themis
vim-themis/bin/themis --reporter spec test/commands.vim test/parse.vim test/sample.vim test/tsort.vim test/toml.vim
vim-themis/bin/themis --reporter spec test/source.vim
vim-themis/bin/themis --reporter spec test/lock.vim
# Use existing vim-themis install from ~/.vim, or clone it.
vim-themis:
existing=$(firstword $(wildcard ~/.vim/*bundle*/*themis*/plugin/themis.vim)); \
if [ -n "$$existing" ]; then \
( cd test && ln -s $$(dirname $$(dirname $$existing)) vim-themis ); \
else \
git clone https://github.com/thinca/vim-themis vim-themis; \
fi
.PHONY: test

148
.vim/bundle/neobundle.vim/README.md Normal file
View file

@ -0,0 +1,148 @@
[![Stories in Ready](https://badge.waffle.io/Shougo/neobundle.vim.png)](https://waffle.io/Shougo/neobundle.vim)
**Note**: Active developement on NeoBundle has stopped. The only future changes will be bug fixes.
Please see [Dein.vim](https://github.com/Shougo/dein.vim) -- A faster, well-tested plugin manager for Vim and Neovim. It can do everything NeoBundle does, including asynchronous installs.
## About
NeoBundle is a next generation Vim plugin manager. This plugin is based on
[Vundle](https://github.com/gmarik/vundle), but I renamed and added tons of
features, while Vundle tends to stay simple.
Requirements:
* Vim 7.2.051 or above.
* "git" command in $PATH (if you want to install github or vim.org plugins)
Recommends:
* [vimproc](https://github.com/Shougo/vimproc.vim) if you want to
install/update asynchronously in Unite interface.
Note: In :NeoBundleUpdate/:NeoBundleInstall commands, you can parallel update by
vimproc, but you cannot do other work unlike Unite interface.
Note: Neobundle is not a stable plugin manager. If you want a stable plugin
manager, you should use Vundle plugin. It well works widely and it is more
tested. If you want to use extended features, you can use neobundle.
Vundle features: Stable, simple, good for beginners
Neobundle features: Early development (may break compatibility), very complex,
good for plugin power users (for example, 50+ plugins and over 1000 lines
.vimrc, ...)
Note: Neobunle only accepts "https" or "ssh".
https://glyph.twistedmatrix.com/2015/11/editor-malware.html
## How it works
Plugins are defined in NeoBundle by calling `NeoBundle '<plugin repository
location>'`. NeoBundle assumes Github as the default location for plugins, so
for most plugins you can simply use `NeoBundle 'username/plugin'` rather than
using the absolute URL of the plugin. These calls should be made in your
.vimrc file. Once you have defined these, you must call `NeoBundleInstall`,
and NeoBundle will clone all of the repos into the desired folder (generally
`~/.vim/bundle`) and load them into Vim. If you want to update these
repositories, simply call `NeoBundleUpdate`.
A few other useful commands:
- `:NeoBundleList` - list configured bundles
- `:NeoBundleInstall(!)` - install (update) bundles
Refer to `:help neobundle` for more examples and for a full list of commands.
## Quick start
### 1. Install NeoBundle
#### If you are using Unix/Linux or Mac OS X.
1. Run below script.
```
$ curl https://raw.githubusercontent.com/Shougo/neobundle.vim/master/bin/install.sh > install.sh
$ sh ./install.sh
```
Complete.
#### If you want to install manually or you are using Windows.
1. Setup NeoBundle:
```
$ mkdir ~/.vim/bundle
$ git clone https://github.com/Shougo/neobundle.vim ~/.vim/bundle/neobundle.vim
```
2. Configure bundles:
Sample `.vimrc`:
```vim
" Note: Skip initialization for vim-tiny or vim-small.
if 0 | endif
if &compatible
set nocompatible " Be iMproved
endif
" Required:
set runtimepath+=~/.vim/bundle/neobundle.vim/
" Required:
call neobundle#begin(expand('~/.vim/bundle/'))
" Let NeoBundle manage NeoBundle
" Required:
NeoBundleFetch 'Shougo/neobundle.vim'
" My Bundles here:
" Refer to |:NeoBundle-examples|.
" Note: You don't set neobundle setting in .gvimrc!
call neobundle#end()
" Required:
filetype plugin indent on
" If there are uninstalled bundles found on startup,
" this will conveniently prompt you to install them.
NeoBundleCheck
```
### 2. Install configured bundles
Launch `vim`, run `:NeoBundleInstall` or `:Unite neobundle/install` (required
unite.vim) Or Command run `bin/neoinstall` or `vim +NeoBundleInstall +qall`
## How to test
Run `make test` command in command line(required vim-themis).
https://github.com/thinca/vim-themis
## Advantages over Vundle
1. Plugin prefixed command name (:Bundle vs :NeoBundle).
2. Support for vimproc (asynchronous update/install).
3. Support for unite.vim interface (update/install/search).
4. Support for revision locking.
5. Support for multiple version control systems (Subversion/Git).
6. Support for lazy initialization for optimizing startup time.
7. and so on...
## Tips
If you use a single .vimrc across systems where build programs are
named differently (e.g. GNU Make is often `gmake` on non-GNU
systems), the following pattern is useful:
```vim
let g:make = 'gmake'
if system('uname -o') =~ '^GNU/'
let g:make = 'make'
endif
NeoBundle 'Shougo/vimproc.vim', {'build': {'unix': g:make}}
```

448
.vim/bundle/neobundle.vim/autoload/neobundle.vim Normal file
View file

@ -0,0 +1,448 @@
"=============================================================================
" FILE: neobundle.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu at gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Check 'term' option value.
if exists('g:loaded_neobundle') && &term ==# 'builtin_gui'
echoerr 'neobundle is initialized in .gvimrc!'
\' neobundle must be initialized in .vimrc.'
endif
if v:version < 702
echoerr 'neobundle does not work this version of Vim (' . v:version . ').'
finish
endif
" Global options definition." "{{{
call neobundle#util#set_default(
\ 'g:neobundle#log_filename', '', 'g:neobundle_log_filename')
call neobundle#util#set_default(
\ 'g:neobundle#default_site', 'github', 'g:neobundle_default_site')
call neobundle#util#set_default(
\ 'g:neobundle#enable_name_conversion', 0)
call neobundle#util#set_default(
\ 'g:neobundle#default_options', {})
call neobundle#util#set_default(
\ 'g:neobundle#install_max_processes', 8,
\ 'g:unite_source_neobundle_install_max_processes')
call neobundle#util#set_default(
\ 'g:neobundle#install_process_timeout', 120)
"}}}
let g:neobundle#tapped = {}
let g:neobundle#hooks = {}
let s:neobundle_dir = ''
let s:neobundle_runtime_dir = neobundle#util#substitute_path_separator(
\ fnamemodify(expand('<sfile>'), ':p:h:h'))
command! -nargs=+
\ NeoBundle
\ call neobundle#parser#bundle(
\ substitute(<q-args>, '\s"[^"]\+$', '', ''))
command! -bar
\ NeoBundleCheck
\ call neobundle#commands#check()
command! -nargs=? -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleCheckUpdate
\ call neobundle#commands#check_update(<q-args>)
command! -nargs=+
\ NeoBundleLazy
\ call neobundle#parser#lazy(
\ substitute(<q-args>, '\s"[^"]\+$', '', ''))
command! -nargs=+
\ NeoBundleFetch
\ call neobundle#parser#fetch(
\ substitute(<q-args>, '\s"[^"]\+$', '', ''))
command! -nargs=1 -complete=dir -bar
\ NeoBundleLocal
\ call neobundle#local(<q-args>, {})
command! -nargs=+ -bar
\ NeoBundleDirectInstall
\ call neobundle#parser#direct(
\ substitute(<q-args>, '\s"[^"]\+$', '', ''))
command! -nargs=* -bar
\ -complete=customlist,neobundle#commands#complete_lazy_bundles
\ NeoBundleSource
\ call neobundle#commands#source([<f-args>])
command! -nargs=+ -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleDisable
\ call neobundle#config#disable(<f-args>)
command! -nargs=? -bang -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleInstall
\ call neobundle#commands#install(
\ '!' == '<bang>', <q-args>)
command! -nargs=? -bang -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleUpdate
\ call neobundle#commands#install(
\ ('!' == '<bang>' ? 2 : 1), <q-args>)
command! -nargs=+ -bang -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleReinstall
\ call neobundle#commands#reinstall(<q-args>)
command! -nargs=? -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleGC
\ call neobundle#commands#gc(<q-args>)
command! -nargs=? -bang -bar
\ NeoBundleList
\ call neobundle#commands#list()
command! -bar
\ NeoBundleDocs
\ call neobundle#commands#helptags(
\ neobundle#config#get_enabled_bundles())
command! -bar
\ NeoBundleLog
\ echo join(neobundle#installer#get_log(), "\n")
command! -bar
\ NeoBundleUpdatesLog
\ echo join(neobundle#installer#get_updates_log(), "\n")
command! -bar
\ NeoBundleExtraEdit
\ execute 'edit' fnameescape(
\ neobundle#get_neobundle_dir()).'/extra_bundles.vim'
command! -bar
\ NeoBundleCount
\ echo len(neobundle#config#get_neobundles())
command! -bar
\ NeoBundleSaveCache
\ call neobundle#commands#save_cache()
command! -bar
\ NeoBundleLoadCache
\ call neobundle#util#print_error(
\ 'NeoBundleLoadCache is deprecated command.') |
\ call neobundle#util#print_error(
\ 'It will be removed in the next version.') |
\ call neobundle#util#print_error(
\ 'Please use neobundle#load_cache() instead.') |
\ call neobundle#commands#load_cache([$MYVIMRC])
command! -bar
\ NeoBundleClearCache
\ call neobundle#commands#clear_cache()
command! -nargs=1 -bar
\ -complete=customlist,neobundle#commands#complete_bundles
\ NeoBundleRollback
\ call neobundle#commands#rollback(<f-args>)
command! -nargs=+ -bar
\ NeoBundleLock
\ call neobundle#commands#lock(<f-args>)
command! -bar
\ NeoBundleRemotePlugins
\ call neobundle#commands#remote_plugins()
function! neobundle#rc(...) abort "{{{
call neobundle#util#print_error(
\ 'neobundle#rc() is removed function.')
call neobundle#util#print_error(
\ 'Please use neobundle#begin()/neobundle#end() instead.')
return 1
endfunction"}}}
function! neobundle#begin(...) abort "{{{
if a:0 > 0
let path = a:1
else
" Use default path
let paths = filter(split(globpath(&runtimepath,
\ 'bundle', 1), '\n'), 'isdirectory(v:val)')
if empty(paths)
let rtps = neobundle#util#split_rtp(&runtimepath)
if empty(rtps)
call neobundle#util#print_error(
\ 'Invalid runtimepath is detected.')
call neobundle#util#print_error(
\ 'Please check your .vimrc.')
return 1
endif
let paths = [rtps[0].'/bundle']
endif
let path = paths[0]
endif
return neobundle#init#_rc(path)
endfunction"}}}
function! neobundle#append() abort "{{{
call neobundle#config#append()
endfunction"}}}
function! neobundle#end() abort "{{{
call neobundle#config#final()
endfunction"}}}
function! neobundle#add(repository, ...) abort "{{{
let options = get(a:000, 0, {})
let bundle = neobundle#parser#_init_bundle(
\ a:repository, [options])
if empty(bundle)
return {}
endif
let bundle.orig_arg = [a:repository, options]
call neobundle#config#add(bundle)
return bundle
endfunction"}}}
function! neobundle#add_meta(name, ...) abort "{{{
let metadata = neobundle#metadata#get(a:name)
if empty(metadata)
call neobundle#util#print_error(
\ 'Plugin name "' . a:name . '" is not found.')
return {}
endif
let repository = substitute(metadata.url, '^git://', 'https://', '')
let options = { 'name' : a:name }
if has_key(metadata, 'addon-info')
\ && has_key(metadata['addon-info'], 'dependencies')
let options.depends = map(keys(metadata['addon-info'].dependencies),
\ "substitute(neobundle#metadata#get(v:val).url,
\ '^git://', 'https://', '')")
endif
call extend(options, get(a:000, 0, {}))
return neobundle#add(repository, options)
endfunction"}}}
function! neobundle#set_neobundle_dir(path) abort "{{{
let s:neobundle_dir = a:path
endfunction"}}}
function! neobundle#get_neobundle_dir() abort "{{{
if s:neobundle_dir == ''
call neobundle#util#print_error(
\ 'neobundle directory is empty.')
return ''
endif
let dir = s:neobundle_dir
if !isdirectory(dir)
call mkdir(dir, 'p')
endif
return dir
endfunction"}}}
function! neobundle#get_runtime_dir() abort "{{{
return s:neobundle_runtime_dir
endfunction"}}}
function! neobundle#get_tags_dir() abort "{{{
if s:neobundle_dir == ''
return ''
endif
let dir = s:neobundle_dir . '/.neobundle/doc'
if !isdirectory(dir)
call mkdir(dir, 'p')
endif
return dir
endfunction"}}}
function! neobundle#get_rtp_dir() abort "{{{
if s:neobundle_dir == ''
return ''
endif
let dir = s:neobundle_dir . '/.neobundle'
if !isdirectory(dir)
call mkdir(dir, 'p')
endif
return dir
endfunction"}}}
function! neobundle#source(bundle_names) abort "{{{
return neobundle#config#source(a:bundle_names)
endfunction"}}}
function! neobundle#local(localdir, ...) abort "{{{
return neobundle#parser#local(
\ a:localdir, get(a:000, 0, {}), get(a:000, 1, ['*']))
endfunction"}}}
function! neobundle#exists_not_installed_bundles() abort "{{{
return !empty(neobundle#get_not_installed_bundles([]))
endfunction"}}}
function! neobundle#is_installed(...) abort "{{{
return type(get(a:000, 0, [])) == type([]) ?
\ !empty(neobundle#_get_installed_bundles(get(a:000, 0, []))) :
\ neobundle#config#is_installed(a:1)
endfunction"}}}
function! neobundle#is_sourced(name) abort "{{{
return neobundle#config#is_sourced(a:name)
endfunction"}}}
function! neobundle#has_cache() abort "{{{
call neobundle#util#print_error(
\ 'neobundle#has_cache() is deprecated function.')
call neobundle#util#print_error(
\ 'It will be removed in the next version.')
call neobundle#util#print_error(
\ 'Please use neobundle#load_cache() instead.')
return filereadable(neobundle#commands#get_cache_file())
endfunction"}}}
function! neobundle#load_cache(...) abort "{{{
let vimrcs = len(a:000) == 0 ? [$MYVIMRC] : a:000
return neobundle#commands#load_cache(vimrcs)
endfunction"}}}
function! neobundle#get_not_installed_bundle_names() abort "{{{
return map(neobundle#get_not_installed_bundles([]), 'v:val.name')
endfunction"}}}
function! neobundle#get_not_installed_bundles(bundle_names) abort "{{{
let bundles = empty(a:bundle_names) ?
\ neobundle#config#get_neobundles() :
\ neobundle#config#fuzzy_search(a:bundle_names)
call neobundle#installer#_load_install_info(bundles)
return filter(copy(bundles), "
\ !v:val.disabled && v:val.path != '' && !v:val.local
\ && !isdirectory(neobundle#util#expand(v:val.path))
\")
endfunction"}}}
function! neobundle#get_force_not_installed_bundles(bundle_names) abort "{{{
let bundles = empty(a:bundle_names) ?
\ neobundle#config#get_neobundles() :
\ neobundle#config#fuzzy_search(a:bundle_names)
call neobundle#installer#_load_install_info(bundles)
return filter(copy(bundles), "
\ !v:val.disabled && v:val.path != '' && !v:val.local
\ && (!isdirectory(neobundle#util#expand(v:val.path))
\ || v:val.install_rev !=#
\ neobundle#installer#get_revision_number(v:val))
\")
endfunction"}}}
function! neobundle#get(name) abort "{{{
return neobundle#config#get(a:name)
endfunction"}}}
function! neobundle#get_hooks(name) abort "{{{
return get(neobundle#config#get(a:name), 'hooks', {})
endfunction"}}}
function! neobundle#tap(name) abort "{{{
let g:neobundle#tapped = neobundle#get(a:name)
let g:neobundle#hooks = get(neobundle#get(a:name), 'hooks', {})
return !empty(g:neobundle#tapped) && !g:neobundle#tapped.disabled
endfunction"}}}
function! neobundle#untap() abort "{{{
let g:neobundle#tapped = {}
let g:neobundle#hooks = {}
endfunction"}}}
function! neobundle#bundle(arg, ...) abort "{{{
let opts = get(a:000, 0, {})
call map(neobundle#util#convert2list(a:arg),
\ "neobundle#config#add(neobundle#parser#_init_bundle(
\ v:val, [deepcopy(opts)]))")
endfunction"}}}
function! neobundle#config(arg, ...) abort "{{{
" Use neobundle#tapped or name.
return type(a:arg) == type({}) ?
\ neobundle#config#set(g:neobundle#tapped.name, a:arg) :
\ type(a:arg) == type('') ?
\ neobundle#config#set(a:arg, a:1) :
\ map(copy(a:arg), "neobundle#config#set(v:val, deepcopy(a:1))")
endfunction"}}}
function! neobundle#call_hook(hook_name, ...) abort "{{{
let bundles = neobundle#util#convert2list(
\ (empty(a:000) ? neobundle#config#get_neobundles() : a:1))
let bundles = filter(copy(bundles),
\ 'has_key(v:val.hooks, a:hook_name)')
if a:hook_name ==# 'on_source' || a:hook_name ==# 'on_post_source'
let bundles = filter(neobundle#config#tsort(filter(bundles,
\ 'neobundle#config#is_sourced(v:val.name) &&
\ neobundle#config#is_installed(v:val.name)')),
\ 'has_key(v:val.hooks, a:hook_name)')
endif
for bundle in bundles
if type(bundle.hooks[a:hook_name]) == type('')
execute 'source' fnameescape(bundle.hooks[a:hook_name])
else
call call(bundle.hooks[a:hook_name], [bundle], bundle)
endif
endfor
endfunction"}}}
function! neobundle#_get_installed_bundles(bundle_names) abort "{{{
let bundles = empty(a:bundle_names) ?
\ neobundle#config#get_neobundles() :
\ neobundle#config#search(a:bundle_names)
return filter(copy(bundles),
\ 'neobundle#config#is_installed(v:val.name)')
endfunction"}}}
function! neobundle#load_toml(filename, ...) abort "{{{
let opts = get(a:000, 0, {})
return neobundle#parser#load_toml(a:filename, opts)
endfunction"}}}
let s:init_vim_path = fnamemodify(expand('<sfile>'), ':h')
\ . '/neobundle/init.vim'
function! neobundle#get_cache_version() abort "{{{
return getftime(s:init_vim_path)
endfunction "}}}
let &cpo = s:save_cpo
unlet s:save_cpo

332
.vim/bundle/neobundle.vim/autoload/neobundle/TOML.vim Normal file
View file

@ -0,0 +1,332 @@
let s:save_cpo = &cpo
set cpo&vim
"
" public api
"
function! neobundle#TOML#parse(text) abort
let input = {
\ 'text': a:text,
\ 'p': 0,
\ 'length': strlen(a:text),
\}
return s:_parse(input)
endfunction
function! neobundle#TOML#parse_file(filename) abort
if !filereadable(a:filename)
throw printf("vital: Text.TOML: No such file `%s'.", a:filename)
endif
let text = join(readfile(a:filename), "\n")
" fileencoding is always utf8
return neobundle#TOML#parse(iconv(text, 'utf8', &encoding))
endfunction
"
" private api
"
" work around: '[^\r\n]*' doesn't work well in old-vim, but "[^\r\n]*" works well
let s:skip_pattern = '\C^\%(\_s\+\|' . "#[^\r\n]*" . '\)'
let s:table_name_pattern = '\%([^ [:tab:]#.[\]=]\+\)'
let s:table_key_pattern = s:table_name_pattern
function! s:_skip(input) abort
while s:_match(a:input, '\%(\_s\|#\)')
let a:input.p = matchend(a:input.text, s:skip_pattern, a:input.p)
endwhile
endfunction
function! s:_consume(input, pattern) abort
call s:_skip(a:input)
let end = matchend(a:input.text, '\C^' . a:pattern, a:input.p)
if end == -1
call s:_error(a:input)
elseif end == a:input.p
return ''
endif
let matched = strpart(a:input.text, a:input.p, end - a:input.p)
let a:input.p = end
return matched
endfunction
function! s:_match(input, pattern) abort
return match(a:input.text, '\C^' . a:pattern, a:input.p) != -1
endfunction
function! s:_eof(input) abort
return a:input.p >= a:input.length
endfunction
function! s:_error(input) abort
let buf = []
let offset = 0
while (a:input.p + offset) < a:input.length && a:input.text[a:input.p + offset] !~# "[\r\n]"
let buf += [a:input.text[a:input.p + offset]]
let offset += 1
endwhile
throw printf("vital: Text.TOML: Illegal toml format at `%s'.", join(buf, ''))
endfunction
function! s:_parse(input) abort
let data = {}
call s:_skip(a:input)
while !s:_eof(a:input)
if s:_match(a:input, '[^ [:tab:]#.[\]]')
let key = s:_key(a:input)
call s:_equals(a:input)
let value = s:_value(a:input)
call s:_put_dict(data, key, value)
unlet value
elseif s:_match(a:input, '\[\[')
let [key, value] = s:_array_of_tables(a:input)
call s:_put_array(data, key, value)
unlet value
elseif s:_match(a:input, '\[')
let [key, value] = s:_table(a:input)
call s:_put_dict(data, key, value)
unlet value
else
call s:_error(a:input)
endif
call s:_skip(a:input)
endwhile
return data
endfunction
function! s:_key(input) abort
let s = s:_consume(a:input, s:table_key_pattern)
return s
endfunction
function! s:_equals(input) abort
call s:_consume(a:input, '=')
return '='
endfunction
function! s:_value(input) abort
call s:_skip(a:input)
if s:_match(a:input, '"\{3}')
return s:_multiline_basic_string(a:input)
elseif s:_match(a:input, '"\{1}')
return s:_basic_string(a:input)
elseif s:_match(a:input, "'\\{3}")
return s:_multiline_literal(a:input)
elseif s:_match(a:input, "'\\{1}")
return s:_literal(a:input)
elseif s:_match(a:input, '\[')
return s:_array(a:input)
elseif s:_match(a:input, '\%(true\|false\)')
return s:_boolean(a:input)
elseif s:_match(a:input, '\d\{4}-')
return s:_datetime(a:input)
elseif s:_match(a:input, '[+-]\?\%(\d\+\.\d\|\d\+\%(\.\d\+\)\?[eE]\)')
return s:_float(a:input)
else
return s:_integer(a:input)
endif
endfunction
"
" String
"
function! s:_basic_string(input) abort
let s = s:_consume(a:input, '"\%(\\"\|[^"]\)*"')
let s = s[1 : -2]
return s:_unescape(s)
endfunction
function! s:_multiline_basic_string(input) abort
let s = s:_consume(a:input, '"\{3}\_.\{-}"\{3}')
let s = s[3 : -4]
let s = substitute(s, "^\n", '', '')
let s = substitute(s, '\\' . "\n" . '\_s*', '', 'g')
return s:_unescape(s)
endfunction
function! s:_literal(input) abort
let s = s:_consume(a:input, "'[^']*'")
return s[1 : -2]
endfunction
function! s:_multiline_literal(input) abort
let s = s:_consume(a:input, "'\\{3}.\\{-}'\\{3}")
let s = s[3 : -4]
let s = substitute(s, "^\n", '', '')
return s
endfunction
"
" Integer
"
function! s:_integer(input) abort
let s = s:_consume(a:input, '[+-]\?\d\+')
return str2nr(s)
endfunction
"
" Float
"
function! s:_float(input) abort
if s:_match(a:input, '[+-]\?[0-9.]\+[eE][+-]\?\d\+')
return s:_exponent(a:input)
else
return s:_fractional(a:input)
endif
endfunction
function! s:_fractional(input) abort
let s = s:_consume(a:input, '[+-]\?[0-9.]\+')
return str2float(s)
endfunction
function! s:_exponent(input) abort
let s = s:_consume(a:input, '[+-]\?[0-9.]\+[eE][+-]\?\d\+')
return str2float(s)
endfunction
"
" Boolean
"
function! s:_boolean(input) abort
let s = s:_consume(a:input, '\%(true\|false\)')
return (s ==# 'true') ? 1 : 0
endfunction
"
" Datetime
"
function! s:_datetime(input) abort
let s = s:_consume(a:input, '\d\{4}-\d\{2}-\d\{2}T\d\{2}:\d\{2}:\d\{2}\%(Z\|-\?\d\{2}:\d\{2}\|\.\d\+-\d\{2}:\d\{2}\)')
return s
endfunction
"
" Array
"
function! s:_array(input) abort
let ary = []
let _ = s:_consume(a:input, '\[')
call s:_skip(a:input)
while !s:_eof(a:input) && !s:_match(a:input, '\]')
let ary += [s:_value(a:input)]
call s:_consume(a:input, ',\?')
call s:_skip(a:input)
endwhile
let _ = s:_consume(a:input, '\]')
return ary
endfunction
"
" Table
"
function! s:_table(input) abort
let tbl = {}
let name = s:_consume(a:input, '\[\s*' . s:table_name_pattern . '\%(\s*\.\s*' . s:table_name_pattern . '\)*\s*\]')
let name = name[1 : -2]
call s:_skip(a:input)
" while !s:_eof(a:input) && !s:_match(a:input, '\[\{1,2}[a-zA-Z0-9.]\+\]\{1,2}')
while !s:_eof(a:input) && !s:_match(a:input, '\[')
let key = s:_key(a:input)
call s:_equals(a:input)
let value = s:_value(a:input)
let tbl[key] = value
unlet value
call s:_skip(a:input)
endwhile
return [name, tbl]
endfunction
"
" Array of tables
"
function! s:_array_of_tables(input) abort
let tbl = {}
let name = s:_consume(a:input, '\[\[\s*' . s:table_name_pattern . '\%(\s*\.\s*' . s:table_name_pattern . '\)*\s*\]\]')
let name = name[2 : -3]
call s:_skip(a:input)
" while !s:_eof(a:input) && !s:_match(a:input, '\[\{1,2}[a-zA-Z0-9.]\+\]\{1,2}')
while !s:_eof(a:input) && !s:_match(a:input, '\[')
let key = s:_key(a:input)
call s:_equals(a:input)
let value = s:_value(a:input)
let tbl[key] = value
unlet value
call s:_skip(a:input)
endwhile
return [name, [tbl]]
endfunction
function! s:_unescape(text) abort
let text = a:text
let text = substitute(text, '\\"', '"', 'g')
let text = substitute(text, '\\b', "\b", 'g')
let text = substitute(text, '\\t', "\t", 'g')
let text = substitute(text, '\\n', "\n", 'g')
let text = substitute(text, '\\f', "\f", 'g')
let text = substitute(text, '\\r', "\r", 'g')
let text = substitute(text, '\\/', "/", 'g')
let text = substitute(text, '\\\\', '\', 'g')
let text = substitute(text, '\C\\u\(\x\{4}\)', '\=s:_nr2char("0x" . submatch(1))', 'g')
let text = substitute(text, '\C\\U\(\x\{8}\)', '\=s:_nr2char("0x" . submatch(1))', 'g')
return text
endfunction
function! s:_nr2char(nr) abort
return iconv(nr2char(a:nr), &encoding, 'utf8')
endfunction
function! s:_put_dict(dict, key, value) abort
let keys = split(a:key, '\.')
let ref = a:dict
for key in keys[ : -2]
if has_key(ref, key) && type(ref[key]) == type({})
let ref = ref[key]
elseif has_key(ref, key) && type(ref[key]) == type([])
let ref = ref[key][-1]
else
let ref[key] = {}
let ref = ref[key]
endif
endfor
let ref[keys[-1]] = a:value
endfunction
function! s:_put_array(dict, key, value) abort
let keys = split(a:key, '\.')
let ref = a:dict
for key in keys[ : -2]
let ref[key] = get(ref, key, {})
if type(ref[key]) == type([])
let ref = ref[key][-1]
else
let ref = ref[key]
endif
endfor
let ref[keys[-1]] = get(ref, keys[-1], []) + a:value
endfunction
let &cpo = s:save_cpo
unlet s:save_cpo
" vim:set et ts=2 sts=2 sw=2 tw=0:

275
.vim/bundle/neobundle.vim/autoload/neobundle/autoload.vim Normal file
View file

@ -0,0 +1,275 @@
"=============================================================================
" FILE: autoload.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu at gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#autoload#init() abort "{{{
let s:active_auto_source = 0
let s:loaded_path = 0
augroup neobundle
autocmd FileType *
\ call s:on_filetype()
autocmd FuncUndefined *
\ call s:on_function()
autocmd InsertEnter *
\ call s:on_insert()
augroup END
if has('patch-7.4.414')
autocmd neobundle CmdUndefined *
\ call s:on_command_prefix()
endif
augroup neobundle-path
autocmd!
augroup END
for event in [
\ 'BufRead', 'BufCreate', 'BufEnter',
\ 'BufWinEnter', 'BufNew', 'VimEnter', 'BufNewFile'
\ ]
execute 'autocmd neobundle-path' event
\ "* call s:on_path(expand('<afile>'), ".string(event) . ")"
endfor
augroup neobundle-focus
autocmd!
autocmd CursorHold * if s:active_auto_source
\ | call s:source_focus()
\ | endif
autocmd FocusLost * let s:active_auto_source = 1 | call s:source_focus()
autocmd FocusGained * let s:active_auto_source = 0
augroup END
endfunction"}}}
function! neobundle#autoload#_command(command, name, args, bang, line1, line2) abort "{{{
call neobundle#config#source(a:name)
if !exists(':' . a:command)
call neobundle#util#print_error(
\ printf('command %s is not found.', a:command))
return
endif
let range = (a:line1 == a:line2) ? '' :
\ (a:line1==line("'<") && a:line2==line("'>")) ?
\ "'<,'>" : a:line1.",".a:line2
try
execute range.a:command.a:bang a:args
catch /^Vim\%((\a\+)\)\=:E481/
" E481: No range allowed
execute a:command.a:bang a:args
endtry
endfunction"}}}
function! neobundle#autoload#_command_dummy_complete(arglead, cmdline, cursorpos) abort "{{{
" Load plugins
let command = tolower(matchstr(a:cmdline, '\a\S*'))
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "!empty(filter(map(copy(v:val.pre_cmd), 'tolower(v:val)'),
\ 'stridx(command, v:val) == 0'))")
call neobundle#config#source_bundles(bundles)
" Print the candidates
call feedkeys("\<C-d>", 'n')
return ['']
endfunction"}}}
function! neobundle#autoload#_mapping(mapping, name, mode) abort "{{{
let cnt = v:count > 0 ? v:count : ''
let input = s:get_input()
call neobundle#config#source(a:name)
if a:mode ==# 'v' || a:mode ==# 'x'
call feedkeys('gv', 'n')
elseif a:mode ==# 'o'
" TODO: omap
" v:prevcount?
" Cancel waiting operator mode.
call feedkeys(v:operator, 'm')
endif
call feedkeys(cnt, 'n')
let mapping = a:mapping
while mapping =~ '<[[:alnum:]-]\+>'
let mapping = substitute(mapping, '\c<Leader>',
\ get(g:, 'mapleader', '\'), 'g')
let mapping = substitute(mapping, '\c<LocalLeader>',
\ get(g:, 'maplocalleader', '\'), 'g')
let ctrl = matchstr(mapping, '<\zs[[:alnum:]-]\+\ze>')
execute 'let mapping = substitute(
\ mapping, "<' . ctrl . '>", "\<' . ctrl . '>", "")'
endwhile
call feedkeys(mapping . input, 'm')
return ''
endfunction"}}}
function! neobundle#autoload#_source(bundle_name) abort "{{{
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "index(v:val.on_source, a:bundle_name) >= 0")
if !empty(bundles)
call neobundle#config#source_bundles(bundles)
endif
endfunction"}}}
function! neobundle#autoload#_set_function_prefixes(bundles) abort "{{{
for bundle in filter(copy(a:bundles), "empty(v:val.pre_func)")
let bundle.pre_func =
\ neobundle#util#uniq(map(split(globpath(
\ bundle.path, 'autoload/**/*.vim', 1), "\n"),
\ "substitute(matchstr(
\ neobundle#util#substitute_path_separator(
\ fnamemodify(v:val, ':r')),
\ '/autoload/\\zs.*$'), '/', '#', 'g').'#'"))
endfor
endfunction"}}}
function! s:on_filetype() abort "{{{
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "!empty(v:val.on_ft)")
for filetype in add(neobundle#util#get_filetypes(), 'all')
call neobundle#config#source_bundles(filter(copy(bundles),"
\ index(v:val.on_ft, filetype) >= 0"))
endfor
endfunction"}}}
function! s:on_insert() abort "{{{
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "v:val.on_i")
if !empty(bundles)
call neobundle#config#source_bundles(bundles)
doautocmd InsertEnter
endif
endfunction"}}}
function! s:on_function() abort "{{{
let function = expand('<amatch>')
let function_prefix = substitute(function, '[^#]*$', '', '')
if function_prefix =~# '^neobundle#'
\ || function_prefix ==# 'vital#'
\ || has('vim_starting')
return
endif
let bundles = neobundle#config#get_autoload_bundles()
call neobundle#autoload#_set_function_prefixes(bundles)
let bundles = filter(bundles,
\ "index(v:val.pre_func, function_prefix) >= 0
\ || (index(v:val.on_func, function) >= 0)")
call neobundle#config#source_bundles(bundles)
endfunction"}}}
function! s:on_command_prefix() abort "{{{
let command = tolower(expand('<afile>'))
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "!empty(filter(map(copy(v:val.pre_cmd), 'tolower(v:val)'),
\ 'stridx(command, v:val) == 0'))")
call neobundle#config#source_bundles(bundles)
endfunction"}}}
function! s:on_path(path, event) abort "{{{
if a:path == ''
return
endif
let path = a:path
" For ":edit ~".
if fnamemodify(path, ':t') ==# '~'
let path = '~'
endif
let path = neobundle#util#expand(path)
let bundles = filter(neobundle#config#get_autoload_bundles(),
\ "len(filter(copy(v:val.on_path),
\ 'path =~? v:val')) > 0")")
if !empty(bundles)
call neobundle#config#source_bundles(bundles)
execute 'doautocmd' a:event
if !s:loaded_path && has('vim_starting')
\ && neobundle#util#redir('filetype') =~# 'detection:ON'
" Force enable auto detection if path bundles are loaded
autocmd neobundle VimEnter * filetype detect
endif
let s:loaded_path = 1
endif
endfunction"}}}
function! s:source_focus() abort "{{{
let bundles = neobundle#util#sort_by(filter(
\ neobundle#config#get_autoload_bundles(),
\ "v:val.focus > 0"), 'v:val.focus')
if empty(bundles)
augroup neobundle-focus
autocmd!
augroup END
return
endif
call neobundle#config#source_bundles([bundles[0]])
call feedkeys("g\<ESC>", 'n')
endfunction"}}}
function! s:get_input() abort "{{{
let input = ''
let termstr = "<M-_>"
call feedkeys(termstr, 'n')
let type_num = type(0)
while 1
let char = getchar()
let input .= (type(char) == type_num) ? nr2char(char) : char
let idx = stridx(input, termstr)
if idx >= 1
let input = input[: idx - 1]
break
elseif idx == 0
let input = ''
break
endif
endwhile
return input
endfunction"}}}
function! s:get_lazy_bundles() abort "{{{
return filter(neobundle#config#get_neobundles(),
\ "!v:val.sourced && v:val.rtp != '' && v:val.lazy")
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo

79
.vim/bundle/neobundle.vim/autoload/neobundle/cache.vim Normal file
View file

@ -0,0 +1,79 @@
" Utilities for output cache.
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#cache#getfilename(cache_dir, filename) abort
return s:_encode_name(a:cache_dir, a:filename)
endfunction
function! neobundle#cache#filereadable(cache_dir, filename) abort
let cache_name = s:_encode_name(a:cache_dir, a:filename)
return filereadable(cache_name)
endfunction
function! neobundle#cache#readfile(cache_dir, filename) abort
let cache_name = s:_encode_name(a:cache_dir, a:filename)
return filereadable(cache_name) ? readfile(cache_name) : []
endfunction
function! neobundle#cache#writefile(cache_dir, filename, list) abort
let cache_name = s:_encode_name(a:cache_dir, a:filename)
call writefile(a:list, cache_name)
endfunction
function! neobundle#cache#deletefile(cache_dir, filename) abort
let cache_name = s:_encode_name(a:cache_dir, a:filename)
return delete(cache_name)
endfunction
function! s:_encode_name(cache_dir, filename) abort
" Check cache directory.
if !isdirectory(a:cache_dir)
call mkdir(a:cache_dir, 'p')
endif
let cache_dir = a:cache_dir
if cache_dir !~ '/$'
let cache_dir .= '/'
endif
return cache_dir . s:_create_hash(cache_dir, a:filename)
endfunction
function! neobundle#cache#check_old_cache(cache_dir, filename) abort
" Check old cache file.
let cache_name = s:_encode_name(a:cache_dir, a:filename)
let ret = getftime(cache_name) == -1
\ || getftime(cache_name) <= getftime(a:filename)
if ret && filereadable(cache_name)
" Delete old cache.
call delete(cache_name)
endif
return ret
endfunction
function! s:_create_hash(dir, str) abort
if len(a:dir) + len(a:str) < 150
let hash = substitute(substitute(
\ a:str, ':', '=-', 'g'), '[/\\]', '=+', 'g')
elseif exists('*sha256')
let hash = sha256(a:str)
else
" Use simple hash.
let sum = 0
for i in range(len(a:str))
let sum += char2nr(a:str[i]) * (i + 1)
endfor
let hash = printf('%x', sum)
endif
return hash
endfunction
let &cpo = s:save_cpo
unlet s:save_cpo
" vim:set et ts=2 sts=2 sw=2 tw=0:

760
.vim/bundle/neobundle.vim/autoload/neobundle/commands.vim Normal file
View file

File diff suppressed because it is too large Load diff

761
.vim/bundle/neobundle.vim/autoload/neobundle/config.vim Normal file
View file

File diff suppressed because it is too large Load diff

300
.vim/bundle/neobundle.vim/autoload/neobundle/init.vim Normal file
View file

@ -0,0 +1,300 @@
"=============================================================================
" FILE: init.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu at gmail.com>
" Copyright (C) 2010 http://github.com/gmarik
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#init#_rc(path) abort "{{{
let path =
\ neobundle#util#substitute_path_separator(
\ neobundle#util#expand(a:path))
if path =~ '/$'
let path = path[: -2]
endif
if path == ''
call neobundle#util#print_error(
\ 'neobundle#rc() argument is empty.')
return
endif
call neobundle#set_neobundle_dir(path)
" Join to the tail in runtimepath.
let rtp = neobundle#get_rtp_dir()
execute 'set rtp-='.fnameescape(rtp)
let rtps = neobundle#util#split_rtp(&runtimepath)
let n = index(rtps, $VIMRUNTIME)
if n < 0
call neobundle#util#print_error(
\ 'Invalid runtimepath is detected.')
call neobundle#util#print_error(
\ 'Please check your .vimrc.')
return
endif
let &runtimepath = neobundle#util#join_rtp(
\ insert(rtps, rtp, n-1), &runtimepath, rtp)
augroup neobundle
autocmd!
augroup END
call neobundle#config#init()
call neobundle#autoload#init()
endfunction"}}}
function! neobundle#init#_bundle(bundle) abort "{{{
if (!has_key(a:bundle, 'type') && get(a:bundle, 'local', 0))
\ || get(a:bundle, 'type', '') ==# 'nosync'
" Default type.
let a:bundle.type = 'none'
endif
if !has_key(a:bundle, 'type')
call neobundle#installer#error(
\ printf('Failed parse name "%s" and args %s',
\ a:bundle.orig_name, string(a:bundle.orig_opts)))
return {}
endif
let bundle = {
\ 'uri' : '',
\ 'script_type' : '',
\ 'rev' : '',
\ 'rtp' : '',
\ 'depends' : [],
\ 'fetch' : 0,
\ 'force' : 0,
\ 'gui' : 0,
\ 'terminal' : 0,
\ 'autoload' : {},
\ 'hooks' : {},
\ 'external_commands' : {},
\ 'build_commands': {},
\ 'description' : '',
\ 'dummy_commands' : [],
\ 'dummy_mappings' : [],
\ 'sourced' : 0,
\ 'disabled' : 0,
\ 'local' : 0,
\ 'focus' : 0,
\ 'verbose' : 0,
\ 'orig_name' : '',
\ 'vim_version' : '',
\ 'orig_opts' : {},
\ 'base' : neobundle#get_neobundle_dir(),
\ 'install_rev' : '',
\ 'install_process_timeout'
\ : g:neobundle#install_process_timeout,
\ 'refcnt' : 1,
\ 'frozen' : 0,
\ 'on_i' : 0,
\ 'on_ft' : [],
\ 'on_cmd' : [],
\ 'on_func' : [],
\ 'on_map' : [],
\ 'on_path' : [],
\ 'on_source' : [],
\ 'pre_cmd' : [],
\ 'pre_func' : [],
\ }
call extend(bundle, a:bundle)
if !has_key(bundle, 'name')
let bundle.name = neobundle#util#name_conversion(bundle.orig_name)
endif
if !has_key(bundle, 'normalized_name')
let bundle.normalized_name = substitute(
\ fnamemodify(bundle.name, ':r'),
\ '\c^vim[_-]\|[_-]vim$', '', 'g')
endif
if !has_key(bundle.orig_opts, 'name') &&
\ g:neobundle#enable_name_conversion
" Use normalized name.
let bundle.name = bundle.normalized_name
endif
if !has_key(bundle, 'directory')
let bundle.directory = bundle.name
if bundle.rev != ''
let bundle.directory .= '_' . substitute(bundle.rev,
\ '[^[:alnum:]_-]', '_', 'g')
endif
endif
if bundle.base[0] == '~'
let bundle.base = neobundle#util#expand(bundle.base)
endif
if bundle.base[-1] == '/' || bundle.base[-1] == '\'
" Chomp.
let bundle.base = bundle.base[: -2]
endif
let bundle.path = isdirectory(bundle.uri) ?
\ bundle.uri : bundle.base.'/'.bundle.directory
" Check relative path.
if bundle.rtp !~ '^\%([~/]\|\a\+:\)'
let bundle.rtp = bundle.path.'/'.bundle.rtp
endif
if bundle.rtp[0] == '~'
let bundle.rtp = neobundle#util#expand(bundle.rtp)
endif
if bundle.rtp[-1] == '/' || bundle.rtp[-1] == '\'
" Chomp.
let bundle.rtp = bundle.rtp[: -2]
endif
if bundle.normalized_name ==# 'neobundle' || bundle.fetch
" Do not add runtimepath.
let bundle.rtp = ''
endif
if bundle.script_type != ''
" Add script_type.
" Note: To check by neobundle#config#is_installed().
let bundle.path .= '/' . bundle.script_type
endif
if !has_key(bundle, 'augroup')
let bundle.augroup = bundle.normalized_name
endif
" Convert old name
if has_key(bundle, 'stay_same')
let bundle.frozen = bundle.stay_same
endif
call s:init_lazy(bundle)
" Parse depends.
if !empty(bundle.depends)
call s:init_depends(bundle)
endif
if type(bundle.disabled) == type('')
let bundle.disabled = eval(bundle.disabled)
endif
let bundle.disabled = bundle.disabled
\ || (bundle.gui && !has('gui_running'))
\ || (bundle.terminal && has('gui_running'))
\ || (bundle.vim_version != ''
\ && s:check_version(bundle.vim_version))
\ || (!empty(bundle.external_commands)
\ && neobundle#config#check_commands(bundle.external_commands))
return bundle
endfunction"}}}
function! s:init_lazy(bundle) abort "{{{
let bundle = a:bundle
" Auto set autoload keys.
for key in filter([
\ 'filetypes', 'filename_patterns',
\ 'commands', 'functions', 'mappings',
\ 'insert', 'explorer',
\ 'command_prefix', 'function_prefixes',
\ ], 'has_key(bundle, v:val)')
let bundle.autoload[key] = bundle[key]
call remove(bundle, key)
endfor
" Auto set on keys.
for [key, value] in items(filter({
\ 'filetypes' : 'on_ft',
\ 'filename_patterns' : 'on_path',
\ 'commands' : 'on_cmd',
\ 'functions' : 'on_func',
\ 'mappings' : 'on_map',
\ 'insert' : 'on_i',
\ 'explorer' : 'on_path',
\ 'on_source' : 'on_source',
\ 'command_prefix' : 'pre_cmd',
\ 'function_prefixes' : 'pre_func',
\ }, 'has_key(bundle.autoload, v:key)'))
let bundle[value] = (key ==# 'explorer'
\ && type(bundle.autoload[key]) == type(0)
\ && bundle.autoload[key] == 1) ? '.*' : bundle.autoload[key]
endfor
if empty(bundle.pre_cmd)
let bundle.pre_cmd = substitute(bundle.normalized_name, '[_-]', '', 'g')
endif
" Auto convert2list.
for key in filter([
\ 'on_ft', 'on_path', 'on_cmd',
\ 'on_func', 'on_map',
\ 'on_source', 'pre_cmd', 'pre_func',
\ ], "type(bundle[v:val]) != type([])
\")
let bundle[key] = [bundle[key]]
endfor
if !has_key(bundle, 'lazy')
" Set lazy flag automatically
let bundle.lazy = bundle.on_i
\ || !empty(filter(['on_ft', 'on_path', 'on_cmd',
\ 'on_func', 'on_map', 'on_source'],
\ '!empty(bundle[v:val])'))
endif
endfunction"}}}
function! s:init_depends(bundle) abort "{{{
let bundle = a:bundle
let _ = []
for depend in neobundle#util#convert2list(bundle.depends)
if type(depend) == type('')
let depend = string(depend)
endif
let depend_bundle = type(depend) == type({}) ?
\ depend : neobundle#parser#bundle(depend, 1)
let depend_bundle.lazy = bundle.lazy
call add(_, depend_bundle)
unlet depend
endfor
let bundle.depends = _
endfunction"}}}
function! s:check_version(min_version) abort "{{{
let versions = split(a:min_version, '\.')
let major = get(versions, 0, 0)
let minor = get(versions, 1, 0)
let patch = get(versions, 2, 0)
let min_version = major * 100 + minor
return v:version < min_version ||
\ (patch != 0 && v:version == min_version && !has('patch'.patch))
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo

892
.vim/bundle/neobundle.vim/autoload/neobundle/installer.vim Normal file
View file

File diff suppressed because it is too large Load diff

84
.vim/bundle/neobundle.vim/autoload/neobundle/metadata.vim Normal file
View file

@ -0,0 +1,84 @@
"=============================================================================
" FILE: metadata.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu at gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
let s:metadata = {}
let s:repository =
\ 'https://gist.githubusercontent.com/Shougo/'
\ . '028d6ae320cc8f354f88/raw/'
\ . '3b62ad42d39a4d3d4f236a45e00eb6b03ca23352/vim-pi.json'
function! neobundle#metadata#get(...) abort "{{{
if empty(s:metadata)
call s:load()
endif
return (a:0 == 0) ? copy(s:metadata) : get(s:metadata, a:1, {})
endfunction"}}}
function! neobundle#metadata#update() abort "{{{
" Reload cache.
let cache_path = neobundle#get_neobundle_dir() . '/.neobundle/metadata.json'
if filereadable(cache_path)
call delete(cache_path)
endif
let cmd = neobundle#util#wget(s:repository, cache_path)
if cmd =~# '^E:'
call neobundle#util#print_error(
\ 'curl or wget command is not available!')
return
endif
let result = neobundle#util#system(cmd)
if neobundle#util#get_last_status()
call neobundle#util#print_error('Error occurred!')
call neobundle#util#print_error(cmd)
call neobundle#util#print_error(result)
elseif !filereadable(cache_path)
call neobundle#util#print_error('Temporary file was not created!')
endif
endfunction"}}}
function! s:load() abort "{{{
" Reload cache.
let cache_path = neobundle#get_neobundle_dir() . '/.neobundle/metadata.json'
if !filereadable(cache_path)
call neobundle#metadata#update()
endif
sandbox let s:metadata = eval(get(readfile(cache_path), 0, '{}'))
return s:metadata
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo

314
.vim/bundle/neobundle.vim/autoload/neobundle/parser.vim Normal file
View file

@ -0,0 +1,314 @@
"=============================================================================
" FILE: parser.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu at gmail.com>
" Copyright (C) 2010 http://github.com/gmarik
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#parser#bundle(arg, ...) abort "{{{
let bundle = s:parse_arg(a:arg)
let is_parse_only = get(a:000, 0, 0)
if !is_parse_only
call neobundle#config#add(bundle)
if !neobundle#config#within_block()
\ && !bundle.lazy && has('vim_starting')
call neobundle#util#print_error(
\ '`NeoBundle` commands must be executed within' .
\ ' a neobundle#begin/end block. Please check your usage.')
endif
endif
return bundle
endfunction"}}}
function! neobundle#parser#lazy(arg) abort "{{{
let bundle = s:parse_arg(a:arg)
if empty(bundle)
return {}
endif
" Update lazy flag.
let bundle.lazy = 1
let bundle.orig_opts.lazy = 1
for depend in bundle.depends
let depend.lazy = bundle.lazy
endfor
call neobundle#config#add(bundle)
return bundle
endfunction"}}}
function! neobundle#parser#fetch(arg) abort "{{{
let bundle = s:parse_arg(a:arg)
if empty(bundle)
return {}
endif
" Clear runtimepath.
let bundle.fetch = 1
let bundle.rtp = ''
call neobundle#config#add(bundle)
return bundle
endfunction"}}}
function! neobundle#parser#direct(arg) abort "{{{
let bundle = neobundle#parser#bundle(a:arg, 1)
if empty(bundle)
return {}
endif
if !empty(neobundle#get(bundle.name))
call neobundle#util#print_error(
\ bundle.name . ' is already installed.')
return {}
endif
call neobundle#config#add(bundle)
call neobundle#config#save_direct(a:arg)
" Direct install.
call neobundle#commands#install(0, bundle.name)
return bundle
endfunction"}}}
function! s:parse_arg(arg) abort "{{{
let arg = type(a:arg) == type([]) ?
\ string(a:arg) : '[' . a:arg . ']'
let args = eval(arg)
if empty(args)
return {}
endif
let bundle = neobundle#parser#_init_bundle(
\ args[0], args[1:])
if empty(bundle)
return {}
endif
let bundle.orig_arg = copy(a:arg)
return bundle
endfunction"}}}
function! neobundle#parser#_init_bundle(name, opts) abort "{{{
let path = substitute(a:name, "['".'"]\+', '', 'g')
if path[0] == '~'
let path = neobundle#util#expand(path)
endif
let opts = s:parse_options(a:opts)
let bundle = extend(neobundle#parser#path(
\ path, opts), opts)
let bundle.orig_name = a:name
let bundle.orig_path = path
let bundle.orig_opts = opts
let bundle.orig_arg = string(a:name).', '.string(opts)
let bundle = neobundle#init#_bundle(bundle)
return bundle
endfunction"}}}
function! neobundle#parser#local(localdir, options, includes) abort "{{{
let base = fnamemodify(neobundle#util#expand(a:localdir), ':p')
let directories = []
for glob in a:includes
let directories += map(filter(split(glob(base . glob), '\n'),
\ "isdirectory(v:val)"), "
\ substitute(neobundle#util#substitute_path_separator(
\ fnamemodify(v:val, ':p')), '/$', '', '')")
endfor
for dir in neobundle#util#uniq(directories)
let options = extend({ 'local' : 1, 'base' : base }, a:options)
let name = fnamemodify(dir, ':t')
let bundle = neobundle#get(name)
if !empty(bundle) && !bundle.sourced
call extend(options, copy(bundle.orig_opts))
if bundle.lazy
let options.lazy = 1
endif
call neobundle#config#rm(bundle)
endif
call neobundle#parser#bundle([dir, options])
endfor
endfunction"}}}
function! neobundle#parser#load_toml(filename, default) abort "{{{
try
let toml = neobundle#TOML#parse_file(neobundle#util#expand(a:filename))
catch /vital: Text.TOML:/
call neobundle#util#print_error(
\ 'Invalid toml format: ' . a:filename)
call neobundle#util#print_error(v:exception)
return 1
endtry
if type(toml) != type({}) || !has_key(toml, 'plugins')
call neobundle#util#print_error(
\ 'Invalid toml file: ' . a:filename)
return 1
endif
" Parse.
for plugin in toml.plugins
if has_key(plugin, 'repository')
let plugin.repo = plugin.repository
endif
if !has_key(plugin, 'repo')
call neobundle#util#print_error(
\ 'No repository plugin data: ' . a:filename)
return 1
endif
if has_key(plugin, 'depends')
let _ = []
for depend in neobundle#util#convert2list(plugin.depends)
if type(depend) == type('') || type(depend) == type([])
call add(_, depend)
elseif type(depend) == type({})
if has_key(depend, 'repository')
let plugin.repo = plugin.repository
endif
if !has_key(depend, 'repo')
call neobundle#util#print_error(
\ 'No repository plugin data: ' . a:filename)
return 1
endif
call add(_, [depend.repo, depend])
endif
unlet depend
endfor
let plugin.depends = _
endif
let options = extend(plugin, a:default, 'keep')
" echomsg string(options)
call neobundle#parser#bundle([plugin.repo, options])
endfor
endfunction"}}}
function! neobundle#parser#path(path, ...) abort "{{{
let opts = get(a:000, 0, {})
let site = get(opts, 'site', g:neobundle#default_site)
let path = substitute(a:path, '/$', '', '')
if path !~ '^/\|^\a:' && path !~ ':'
" Add default site.
let path = site . ':' . path
endif
if has_key(opts, 'type')
let type = neobundle#config#get_types(opts.type)
let types = empty(type) ? [] : [type]
else
let detect = neobundle#config#get_types('git').detect(path, opts)
if !empty(detect)
let detect.name = neobundle#util#name_conversion(path)
return detect
endif
let types = neobundle#config#get_types()
endif
let detect = {}
for type in types
let detect = type.detect(path, opts)
if !empty(detect)
break
endif
endfor
if empty(detect) && isdirectory(path)
" Detect none type.
return { 'uri' : path, 'type' : 'none' }
endif
if !empty(detect) && !has_key(detect, 'name')
let detect.name = neobundle#util#name_conversion(path)
endif
return detect
endfunction"}}}
function! s:parse_options(opts) abort "{{{
if empty(a:opts)
return has_key(g:neobundle#default_options, '_') ?
\ copy(g:neobundle#default_options['_']) : {}
endif
if len(a:opts) == 3
" rev, default, options
let [rev, default, options] = a:opts
elseif len(a:opts) == 2 && type(a:opts[-1]) == type('')
" rev, default
let [rev, default, options] = a:opts + [{}]
elseif len(a:opts) == 2 && type(a:opts[-1]) == type({})
" rev, options
let [rev, default, options] = [a:opts[0], '', a:opts[1]]
elseif len(a:opts) == 1 && type(a:opts[-1]) == type('')
" rev
let [rev, default, options] = [a:opts[0], '', {}]
elseif len(a:opts) == 1 && type(a:opts[-1]) == type({})
" options
let [rev, default, options] = ['', '', a:opts[0]]
else
call neobundle#installer#error(
\ printf('Invalid option : "%s".', string(a:opts)))
return {}
endif
if rev != ''
let options.rev = rev
endif
if !has_key(options, 'default')
let options.default = (default == '') ? '_' : default
endif
" Set default options.
if has_key(g:neobundle#default_options, options.default)
call extend(options,
\ g:neobundle#default_options[options.default], 'keep')
endif
return options
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

119
.vim/bundle/neobundle.vim/autoload/neobundle/sources/github.vim Normal file
View file

@ -0,0 +1,119 @@
"=============================================================================
" FILE: github.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#sources#github#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'github',
\ 'short_name' : 'github',
\ }
" sorter
let s:filter = {
\ "name" : "sorter_stars",
\}
function! s:filter.filter(candidates, context) abort
return unite#util#sort_by(a:candidates, 'v:val.source__stars')
endfunction
call unite#define_filter(s:filter)
unlet s:filter
function! s:source.gather_candidates(args, context) abort "{{{
let plugins = s:get_github_searches(a:context.source__input)
return map(copy(plugins), "{
\ 'word' : v:val.full_name. ' ' . v:val.description,
\ 'source__name' : (v:val.fork ? '| ' : '') .
\ v:val.full_name,
\ 'source__path' : v:val.full_name,
\ 'source__description' : v:val.description,
\ 'source__stars' : v:val.stargazers_count,
\ 'source__options' : [],
\ 'action__uri' : v:val.html_url,
\ }")
endfunction"}}}
" Misc.
" @vimlint(EVL102, 1, l:true)
" @vimlint(EVL102, 1, l:false)
" @vimlint(EVL102, 1, l:null)
function! s:get_github_searches(string) abort "{{{
let uri = 'https://api.github.com/search/repositories?q='
\ . a:string . '+language:VimL'.'\&sort=stars'.'\&order=desc'
let temp = neobundle#util#substitute_path_separator(tempname())
let cmd = neobundle#util#wget(uri, temp)
call unite#print_message(
\ '[neobundle/search:github] Searching plugins from github...')
redraw
let result = unite#util#system(cmd)
if cmd =~# '^E:'
call unite#print_error(
\ '[neobundle/search:github] '.
\ 'wget or curl command is not available!')
return []
elseif unite#util#get_last_status()
call unite#print_message('[neobundle/search:github] ' . cmd)
call unite#print_error('[neobundle/search:github] Error occurred!')
call unite#print_error(result)
return []
elseif !filereadable(temp)
call unite#print_error('[neobundle/search:github] '.
\ 'Temporary file was not created!')
return []
else
call unite#print_message('[neobundle/search:github] Done!')
endif
let [true, false, null] = [1,0,"''"]
sandbox let data = eval(join(readfile(temp)))
call filter(data.items,
\ "stridx(v:val.full_name, a:string) >= 0")
call delete(temp)
return data.items
endfunction"}}}
" @vimlint(EVL102, 0, l:true)
" @vimlint(EVL102, 0, l:false)
" @vimlint(EVL102, 0, l:null)
call unite#custom_source('neobundle/search', 'sorters', 'sorters_stars')
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

104
.vim/bundle/neobundle.vim/autoload/neobundle/sources/metadata.vim Normal file
View file

@ -0,0 +1,104 @@
"=============================================================================
" FILE: metadata.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
let s:repository_cache = []
function! neobundle#sources#metadata#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'metadata',
\ 'short_name' : 'meta',
\ }
function! s:source.gather_candidates(args, context) abort "{{{
let plugins = s:get_repository_plugins(a:context)
try
return map(copy(plugins), "{
\ 'word' : v:val.name . ' ' . v:val.description,
\ 'source__name' : v:val.name,
\ 'source__path' : v:val.repository,
\ 'source__script_type' : s:convert2script_type(v:val.raw_type),
\ 'source__description' : v:val.description,
\ 'source__options' : [],
\ 'action__uri' : v:val.uri,
\ }")
catch
call unite#print_error(
\ '[neobundle/search:metadata] '
\ .'Error occurred in loading cache.')
call unite#print_error(
\ '[neobundle/search:metadata] '
\ .'Please re-make cache by <Plug>(unite_redraw) mapping.')
call neobundle#installer#error(v:exception . ' ' . v:throwpoint)
return []
endtry
endfunction"}}}
" Misc.
function! s:get_repository_plugins(context) abort "{{{
if a:context.is_redraw
" Reload cache.
call unite#print_message(
\ '[neobundle/search:metadata] '
\ .'Reloading cache from metadata repository')
redraw
call neobundle#metadata#update()
endif
return s:convert_metadata(neobundle#metadata#get())
endfunction"}}}
function! s:convert_metadata(data) abort "{{{
return values(map(copy(a:data), "{
\ 'name' : v:key,
\ 'raw_type' : get(v:val, 'script-type', ''),
\ 'repository' : substitute(v:val.url, '^git://', 'https://', ''),
\ 'description' : '',
\ 'uri' : get(v:val, 'homepage', ''),
\ }"))
endfunction"}}}
function! s:convert2script_type(type) abort "{{{
if a:type ==# 'utility'
return 'plugin'
elseif a:type ==# 'color scheme'
return 'colors'
else
return a:type
endif
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

160
.vim/bundle/neobundle.vim/autoload/neobundle/sources/vim_scripts_org.vim Normal file
View file

@ -0,0 +1,160 @@
"=============================================================================
" FILE: vim_scripts_org.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
let s:Cache = unite#util#get_vital_cache()
let s:repository_cache = []
function! neobundle#sources#vim_scripts_org#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'vim-scripts.org',
\ 'short_name' : 'vim.org',
\ }
function! s:source.gather_candidates(args, context) abort "{{{
let repository =
\ 'https://raw.githubusercontent.com/vim-scraper/'
\ .'vim-scraper.github.com/master/api/scripts_recent.json'
call unite#print_message(
\ '[neobundle/search:vim-scripts.org] repository: ' . repository)
let plugins = s:get_repository_plugins(a:context, repository)
try
return map(copy(plugins), "{
\ 'word' : v:val.name . ' ' . v:val.description,
\ 'source__name' : v:val.name,
\ 'source__path' : v:val.name,
\ 'source__script_type' : s:convert2script_type(v:val.raw_type),
\ 'source__description' : v:val.description,
\ 'source__options' : [],
\ 'action__uri' : v:val.uri,
\ }")
catch
call unite#print_error(
\ '[neobundle/search:vim-scripts.org] '
\ .'Error occurred in loading cache.')
call unite#print_error(
\ '[neobundle/search:vim-scripts.org] '
\ .'Please re-make cache by <Plug>(unite_redraw) mapping.')
call neobundle#installer#error(v:exception . ' ' . v:throwpoint)
return []
endtry
endfunction"}}}
" Misc.
function! s:get_repository_plugins(context, path) abort "{{{
let cache_dir = neobundle#get_neobundle_dir() . '/.neobundle'
if a:context.is_redraw || !s:Cache.filereadable(cache_dir, a:path)
" Reload cache.
let cache_path = s:Cache.getfilename(cache_dir, a:path)
call unite#print_message(
\ '[neobundle/search:vim-scripts.org] '
\ .'Reloading cache from ' . a:path)
redraw
if s:Cache.filereadable(cache_dir, a:path)
call delete(cache_path)
endif
let temp = unite#util#substitute_path_separator(tempname())
let cmd = neobundle#util#wget(a:path, temp)
if cmd =~# '^E:'
call unite#print_error(
\ '[neobundle/search:vim-scripts.org] '.
\ 'curl or wget command is not available!')
return []
endif
let result = unite#util#system(cmd)
if unite#util#get_last_status()
call unite#print_message(
\ '[neobundle/search:vim-scripts.org] ' . cmd)
call unite#print_message(
\ '[neobundle/search:vim-scripts.org] ' . result)
call unite#print_error(
\ '[neobundle/search:vim-scripts.org] Error occurred!')
return []
elseif !filereadable(temp)
call unite#print_error('[neobundle/search:vim-scripts.org] '.
\ 'Temporary file was not created!')
return []
else
call unite#print_message('[neobundle/search:vim-scripts.org] Done!')
endif
sandbox let data = eval(get(readfile(temp), 0, '[]'))
" Convert cache data.
call s:Cache.writefile(cache_dir, a:path,
\ [string(s:convert_vim_scripts_data(data))])
call delete(temp)
endif
if empty(s:repository_cache)
sandbox let s:repository_cache =
\ eval(get(s:Cache.readfile(cache_dir, a:path), 0, '[]'))
endif
return s:repository_cache
endfunction"}}}
function! s:convert_vim_scripts_data(data) abort "{{{
return map(copy(a:data), "{
\ 'name' : v:val.n,
\ 'raw_type' : v:val.t,
\ 'repository' : v:val.rv,
\ 'description' : printf('%-5s %s', v:val.rv, v:val.s),
\ 'uri' : 'https://github.com/vim-scripts/' . v:val.n,
\ }")
endfunction"}}}
function! s:convert2script_type(type) abort "{{{
if a:type ==# 'utility'
return 'plugin'
elseif a:type ==# 'color scheme'
return 'colors'
else
return a:type
endif
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

312
.vim/bundle/neobundle.vim/autoload/neobundle/types/git.vim Normal file
View file

@ -0,0 +1,312 @@
"=============================================================================
" FILE: git.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" Robert Nelson <robert@rnelson.ca>
" Copyright (C) 2010 http://github.com/gmarik
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Global options definition. "{{{
call neobundle#util#set_default(
\ 'g:neobundle#types#git#command_path', 'git')
call neobundle#util#set_default(
\ 'g:neobundle#types#git#default_protocol', 'https',
\ 'g:neobundle_default_git_protocol')
call neobundle#util#set_default(
\ 'g:neobundle#types#git#enable_submodule', 1)
call neobundle#util#set_default(
\ 'g:neobundle#types#git#clone_depth', 0,
\ 'g:neobundle_git_clone_depth')
call neobundle#util#set_default(
\ 'g:neobundle#types#git#pull_command', 'pull --ff --ff-only')
"}}}
function! neobundle#types#git#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'git',
\ }
function! s:type.detect(path, opts) abort "{{{
if a:path =~ '^/\|^\a:/' && s:is_git_dir(a:path.'/.git')
" Local repository.
return { 'uri' : a:path, 'type' : 'git' }
elseif isdirectory(a:path)
return {}
endif
let protocol = matchstr(a:path, '^.\{-}\ze://')
if protocol == '' || a:path =~#
\'\<\%(gh\|github\|bb\|bitbucket\):\S\+'
\ || has_key(a:opts, 'type__protocol')
let protocol = get(a:opts, 'type__protocol',
\ g:neobundle#types#git#default_protocol)
endif
if protocol !=# 'https' && protocol !=# 'ssh'
call neobundle#util#print_error(
\ 'Path: ' . a:path . ' The protocol "' . protocol .
\ '" is unsecure and invalid.')
return {}
endif
if a:path !~ '/'
" www.vim.org Vim scripts.
let name = split(a:path, ':')[-1]
let uri = (protocol ==# 'ssh') ?
\ 'git@github.com:vim-scripts/' :
\ protocol . '://github.com/vim-scripts/'
let uri .= name
else
let name = substitute(split(a:path, ':')[-1],
\ '^//github.com/', '', '')
let uri = (protocol ==# 'ssh') ?
\ 'git@github.com:' . name :
\ protocol . '://github.com/'. name
endif
if a:path !~# '\<\%(gh\|github\):\S\+\|://github.com/'
let uri = s:parse_other_pattern(protocol, a:path, a:opts)
if uri == ''
" Parse failure.
return {}
endif
endif
if uri !~ '\.git\s*$'
" Add .git suffix.
let uri .= '.git'
endif
return { 'uri': uri, 'type' : 'git' }
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return 'E: "git" command is not installed.'
endif
if !isdirectory(a:bundle.path)
let cmd = 'clone'
if g:neobundle#types#git#enable_submodule
let cmd .= ' --recursive'
endif
let depth = get(a:bundle, 'type__depth',
\ g:neobundle#types#git#clone_depth)
if depth > 0 && a:bundle.rev == '' && a:bundle.uri !~ '^git@'
let cmd .= ' --depth=' . depth
endif
let cmd .= printf(' %s "%s"', a:bundle.uri, a:bundle.path)
else
let cmd = g:neobundle#types#git#pull_command
if g:neobundle#types#git#enable_submodule
let shell = fnamemodify(split(&shell)[0], ':t')
let and = (!neobundle#util#has_vimproc() && shell ==# 'fish') ?
\ '; and ' : ' && '
let cmd .= and . g:neobundle#types#git#command_path
\ . ' submodule update --init --recursive'
endif
endif
return g:neobundle#types#git#command_path . ' ' . cmd
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
return g:neobundle#types#git#command_path .' rev-parse HEAD'
endfunction"}}}
function! s:type.get_revision_pretty_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
return g:neobundle#types#git#command_path .
\ ' log -1 --pretty=format:"%h [%cr] %s"'
endfunction"}}}
function! s:type.get_commit_date_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
return g:neobundle#types#git#command_path .
\ ' log -1 --pretty=format:"%ct"'
endfunction"}}}
function! s:type.get_log_command(bundle, new_rev, old_rev) abort "{{{
if !executable(g:neobundle#types#git#command_path)
\ || a:new_rev == '' || a:old_rev == ''
return ''
endif
" Note: If the a:old_rev is not the ancestor of two branchs. Then do not use
" %s^. use %s^ will show one commit message which already shown last time.
let is_not_ancestor = neobundle#util#system(
\ g:neobundle#types#git#command_path . ' merge-base '
\ . a:old_rev . ' ' . a:new_rev) ==# a:old_rev
return printf(g:neobundle#types#git#command_path .
\ ' log %s%s..%s --graph --pretty=format:"%%h [%%cr] %%s"',
\ a:old_rev, (is_not_ancestor ? '' : '^'), a:new_rev)
" Test.
" return g:neobundle#types#git#command_path .
" \ ' log HEAD^^^^..HEAD --graph --pretty=format:"%h [%cr] %s"'
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
let rev = a:bundle.rev
if rev ==# 'release'
" Use latest released tag
let rev = neobundle#installer#get_release_revision(a:bundle,
\ g:neobundle#types#git#command_path . ' tag')
endif
if rev == ''
" Fix detach HEAD.
let rev = 'master'
endif
return g:neobundle#types#git#command_path . ' checkout ' . rev
endfunction"}}}
function! s:type.get_gc_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
return g:neobundle#types#git#command_path .' gc'
endfunction"}}}
function! s:type.get_revision_remote_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
let rev = a:bundle.rev
if rev == ''
let rev = 'HEAD'
endif
return g:neobundle#types#git#command_path
\ .' ls-remote origin ' . rev
endfunction"}}}
function! s:type.get_fetch_remote_command(bundle) abort "{{{
if !executable(g:neobundle#types#git#command_path)
return ''
endif
return g:neobundle#types#git#command_path
\ .' fetch origin '
endfunction"}}}
function! s:parse_other_pattern(protocol, path, opts) abort "{{{
let uri = ''
if a:path =~# '\<gist:\S\+\|://gist.github.com/'
let name = split(a:path, ':')[-1]
let uri = (a:protocol ==# 'ssh') ?
\ 'git@gist.github.com:' . split(name, '/')[-1] :
\ a:protocol . '://gist.github.com/'. split(name, '/')[-1]
elseif a:path =~# '\<git@\S\+'
\ || a:path =~# '\.git\s*$'
\ || get(a:opts, 'type', '') ==# 'git'
if a:path =~# '\<\%(bb\|bitbucket\):\S\+'
let name = substitute(split(a:path, ':')[-1],
\ '^//bitbucket.org/', '', '')
let uri = (a:protocol ==# 'ssh') ?
\ 'git@bitbucket.org:' . name :
\ a:protocol . '://bitbucket.org/' . name
else
let uri = a:path
endif
endif
return uri
endfunction"}}}
function! s:is_git_dir(path) abort "{{{
if isdirectory(a:path)
let git_dir = a:path
elseif filereadable(a:path)
" check if this is a gitdir file
" File starts with "gitdir: " and all text after this string is treated
" as the path. Any CR or NLs are stripped off the end of the file.
let buf = join(readfile(a:path, 'b'), "\n")
let matches = matchlist(buf, '\C^gitdir: \(\_.*[^\r\n]\)[\r\n]*$')
if empty(matches)
return 0
endif
let path = fnamemodify(a:path, ':h')
if fnamemodify(a:path, ':t') == ''
" if there's no tail, the path probably ends in a directory separator
let path = fnamemodify(path, ':h')
endif
let git_dir = neobundle#util#join_paths(path, matches[1])
if !isdirectory(git_dir)
return 0
endif
else
return 0
endif
" Git only considers it to be a git dir if a few required files/dirs exist
" and are accessible inside the directory.
" Note: we can't actually test file permissions the way we'd like to, since
" getfperm() gives the mode string but doesn't tell us whether the user or
" group flags apply to us. Instead, just check if dirname/. is a directory.
" This should also check if we have search permissions.
" I'm assuming here that dirname/. works on windows, since I can't test.
" Note: Git also accepts having the GIT_OBJECT_DIRECTORY env var set instead
" of using .git/objects, but we don't care about that.
for name in ['objects', 'refs']
if !isdirectory(neobundle#util#join_paths(git_dir, name))
return 0
endif
endfor
" Git also checks if HEAD is a symlink or a properly-formatted file.
" We don't really care to actually validate this, so let's just make
" sure the file exists and is readable.
" Note: it may also be a symlink, which can point to a path that doesn't
" necessarily exist yet.
let head = neobundle#util#join_paths(git_dir, 'HEAD')
if !filereadable(head) && getftype(head) != 'link'
return 0
endif
" Sure looks like a git directory. There's a few subtleties where we'll
" accept a directory that git itself won't, but I think we can safely ignore
" those edge cases.
return 1
endfunction "}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

119
.vim/bundle/neobundle.vim/autoload/neobundle/types/hg.vim Normal file
View file

@ -0,0 +1,119 @@
"=============================================================================
" FILE: hg.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Global options definition. "{{{
call neobundle#util#set_default(
\ 'g:neobundle#types#hg#command_path', 'hg')
call neobundle#util#set_default(
\ 'g:neobundle#types#hg#default_protocol', 'https',
\ 'g:neobundle_default_hg_protocol')
"}}}
function! neobundle#types#hg#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'hg',
\ }
function! s:type.detect(path, opts) abort "{{{
if isdirectory(a:path.'/.hg')
" Local repository.
return { 'uri' : a:path, 'type' : 'hg' }
elseif isdirectory(a:path)
return {}
endif
let protocol = matchstr(a:path, '^.\{-}\ze://')
if protocol == '' || a:path =~#
\'\<\%(bb\|bitbucket\):\S\+'
\ || has_key(a:opts, 'type__protocol')
let protocol = get(a:opts, 'type__protocol',
\ g:neobundle#types#hg#default_protocol)
endif
if protocol !=# 'https' && protocol !=# 'ssh'
call neobundle#util#print_error(
\ 'Path: ' . a:path . ' The protocol "' . protocol .
\ '" is unsecure and invalid.')
return {}
endif
if a:path =~# '\<\%(bb\|bitbucket\):'
let name = substitute(split(a:path, ':')[-1],
\ '^//bitbucket.org/', '', '')
let uri = (protocol ==# 'ssh') ?
\ 'ssh://hg@bitbucket.org/' . name :
\ protocol . '://bitbucket.org/' . name
elseif a:path =~? '[/.]hg[/.@]'
\ || (a:path =~# '\<https://bitbucket\.org/'
\ || get(a:opts, 'type', '') ==# 'hg')
let uri = a:path
else
return {}
endif
return { 'uri' : uri, 'type' : 'hg' }
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
if !executable(g:neobundle#types#hg#command_path)
return 'E: "hg" command is not installed.'
endif
if !isdirectory(a:bundle.path)
let cmd = 'clone'
let cmd .= printf(' %s "%s"', a:bundle.uri, a:bundle.path)
else
let cmd = 'pull -u'
endif
return g:neobundle#types#hg#command_path . ' ' . cmd
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
if !executable(g:neobundle#types#hg#command_path)
return ''
endif
return g:neobundle#types#hg#command_path
\ . ' heads --quiet --rev default'
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
if !executable(g:neobundle#types#hg#command_path)
\ || a:bundle.rev == ''
return ''
endif
return g:neobundle#types#hg#command_path
\ . ' up ' . a:bundle.rev
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

75
.vim/bundle/neobundle.vim/autoload/neobundle/types/none.vim Normal file
View file

@ -0,0 +1,75 @@
"=============================================================================
" FILE: none.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! neobundle#types#none#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'none',
\ }
function! s:type.detect(path, opts) abort "{{{
" No Auto detect.
return {}
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
if isdirectory(a:bundle.path)
return ''
endif
" Try auto install.
let path = a:bundle.orig_path
let site = get(a:bundle, 'site', g:neobundle#default_site)
if path !~ '^/\|^\a:' && path !~ ':'
" Add default site.
let path = site . ':' . path
endif
for type in neobundle#config#get_types()
let detect = type.detect(path, a:bundle.orig_opts)
if !empty(detect)
return type.get_sync_command(
\ extend(copy(a:bundle), detect))
endif
endfor
return 'E: Failed to auto installation.'
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
return ''
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
return ''
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

116
.vim/bundle/neobundle.vim/autoload/neobundle/types/raw.vim Normal file
View file

@ -0,0 +1,116 @@
"=============================================================================
" FILE: raw.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Global options definition. "{{{
call neobundle#util#set_default(
\ 'g:neobundle#types#raw#calc_hash_command',
\ executable('sha1sum') ? 'sha1sum' :
\ executable('md5sum') ? 'md5sum' : '')
"}}}
function! neobundle#types#raw#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'raw',
\ }
function! s:type.detect(path, opts) abort "{{{
" No auto detect.
let type = ''
let name = ''
if a:path =~# '^https:.*\.vim$'
" HTTPS
let name = neobundle#util#name_conversion(a:path)
let type = 'raw'
elseif a:path =~#
\ '^https://www\.vim\.org/scripts/download_script.php?src_id=\d\+$'
" For www.vim.org
let name = 'vim-scripts-' . matchstr(a:path, '\d\+$')
let type = 'raw'
endif
return type == '' ? {} :
\ { 'name': name, 'uri' : a:path, 'type' : type }
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
if a:bundle.script_type == ''
return 'E: script_type is not found.'
endif
let path = a:bundle.path
if !isdirectory(path)
" Create script type directory.
call mkdir(path, 'p')
endif
let filename = path . '/' . get(a:bundle,
\ 'type__filename', fnamemodify(a:bundle.uri, ':t'))
let a:bundle.type__filepath = filename
let cmd = neobundle#util#wget(a:bundle.uri, filename)
return cmd
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
if g:neobundle#types#raw#calc_hash_command == ''
return ''
endif
if !filereadable(a:bundle.type__filepath)
" Not Installed.
return ''
endif
" Calc hash.
return printf('%s %s',
\ g:neobundle#types#raw#calc_hash_command,
\ a:bundle.type__filepath)
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
let new_rev = matchstr(a:bundle.new_rev, '^\S\+')
if a:bundle.rev != '' && new_rev != '' &&
\ new_rev !=# a:bundle.rev
" Revision check.
return printf('E: revision digest is not matched : "%s"(got) and "%s"(rev).',
\ new_rev, a:bundle.rev)
endif
" Not supported.
return ''
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

93
.vim/bundle/neobundle.vim/autoload/neobundle/types/svn.vim Normal file
View file

@ -0,0 +1,93 @@
"=============================================================================
" FILE: svn.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Global options definition. "{{{
call neobundle#util#set_default(
\ 'g:neobundle#types#svn#command_path', 'svn')
"}}}
function! neobundle#types#svn#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'svn',
\ }
function! s:type.detect(path, opts) abort "{{{
if isdirectory(a:path)
return {}
endif
let type = ''
let uri = ''
if (a:path =~# '\<\%(file\|https\)://'
\ && a:path =~? '[/.]svn[/.]')
\ || a:path =~# '\<svn+ssh://'
let uri = a:path
let type = 'svn'
endif
return type == '' ? {} : { 'uri': uri, 'type' : type }
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
if !executable(g:neobundle#types#svn#command_path)
return 'E: svn command is not installed.'
endif
if !isdirectory(a:bundle.path)
let cmd = 'checkout'
let cmd .= printf(' %s "%s"', a:bundle.uri, a:bundle.path)
else
let cmd = 'up'
endif
return g:neobundle#types#svn#command_path . ' ' . cmd
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
if !executable(g:neobundle#types#svn#command_path)
return ''
endif
return g:neobundle#types#svn#command_path . ' info'
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
if !executable(g:neobundle#types#svn#command_path)
\ || a:bundle.rev == ''
return ''
endif
return g:neobundle#types#svn#command_path
\ . ' up -r ' . a:bundle.rev
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

146
.vim/bundle/neobundle.vim/autoload/neobundle/types/vba.vim Normal file
View file

@ -0,0 +1,146 @@
"=============================================================================
" FILE: vba.vim
" AUTHOR: Yu Huang <paulhybryant@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
" Global options definition. "{{{
call neobundle#util#set_default(
\ 'g:neobundle#types#vba#calc_hash_command',
\ executable('sha1sum') ? 'sha1sum' :
\ executable('md5sum') ? 'md5sum' : '')
"}}}
function! neobundle#types#vba#define() abort "{{{
return s:type
endfunction"}}}
let s:type = {
\ 'name' : 'vba',
\ }
function! s:type.detect(path, opts) abort "{{{
" No auto detect.
let type = ''
let name = ''
if a:path =~# '^https:.*\.vba\(\.gz\)\?$'
" HTTPS
" .*.vba / .*.vba.gz
let name = fnamemodify(split(a:path, ':')[-1],
\ ':s?/$??:t:s?\c\.vba\(\.gz\)*\s*$??')
let type = 'vba'
elseif a:path =~# '\.vba\(\.gz\)\?$' && filereadable(a:path)
" local
" .*.vba
let name = fnamemodify(a:path, ':t:s?\c\.vba\(\.gz\)*\s*$??')
let type = 'vba'
endif
if a:path =~# '^https:.*\.vmb$'
" HTTPS
" .*.vmb
let name = fnamemodify(split(a:path, ':')[-1],
\ ':s?/$??:t:s?\c\.vba\s*$??')
let type = 'vba'
elseif a:path =~# '\.vmb$' && filereadable(a:path)
" local
" .*.vmb
let name = fnamemodify(a:path, ':t:s?\c\.vba\s*$??')
let type = 'vba'
endif
return type == '' ? {} :
\ { 'name': name, 'uri' : a:path, 'type' : type }
endfunction"}}}
function! s:type.get_sync_command(bundle) abort "{{{
let path = a:bundle.path
if !isdirectory(path)
" Create script type directory.
call mkdir(path, 'p')
endif
let filename = path . '/' . get(a:bundle,
\ 'type__filename', fnamemodify(a:bundle.uri, ':t'))
let a:bundle.type__filepath = filename
let cmd = ''
if filereadable(a:bundle.uri)
call writefile(readfile(a:bundle.uri, 'b'), filename, 'b')
else
let cmd = neobundle#util#wget(a:bundle.uri, filename)
if cmd =~# '^E:'
return cmd
endif
let cmd .= ' && '
endif
let cmd .= printf('%s -u NONE' .
\ ' -c "set nocompatible"' .
\ ' -c "filetype plugin on"' .
\ ' -c "runtime plugin/gzip.vim"' .
\ ' -c "runtime plugin/vimballPlugin.vim"' .
\ ' -c "edit %s"' .
\ ' -c "UseVimball %s"' .
\ ' -c "q"', v:progpath, filename, path)
" let cmd .= printf(' rm %s &&', filename)
" let cmd .= printf(' rm %s/.VimballRecord', path)
return cmd
endfunction"}}}
function! s:type.get_revision_number_command(bundle) abort "{{{
if g:neobundle#types#vba#calc_hash_command == ''
return ''
endif
if !has_key(a:bundle, 'type__filepath')
\ || !filereadable(a:bundle.type__filepath)
" Not Installed.
return ''
endif
" Calc hash.
return printf('%s %s',
\ g:neobundle#types#vba#calc_hash_command,
\ a:bundle.type__filepath)
endfunction"}}}
function! s:type.get_revision_lock_command(bundle) abort "{{{
let new_rev = matchstr(a:bundle.new_rev, '^\S\+')
if a:bundle.rev != '' && new_rev != '' &&
\ new_rev !=# a:bundle.rev
" Revision check.
return printf('E: revision digest is not matched : "%s"(got) and "%s"(rev).',
\ new_rev, a:bundle.rev)
endif
" Not supported.
return ''
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

510
.vim/bundle/neobundle.vim/autoload/neobundle/util.vim Normal file
View file

File diff suppressed because it is too large Load diff

106
.vim/bundle/neobundle.vim/autoload/unite/kinds/neobundle.vim Normal file
View file

@ -0,0 +1,106 @@
"=============================================================================
" FILE: neobundle.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! unite#kinds#neobundle#define() abort "{{{
return s:kind
endfunction"}}}
let s:kind = {
\ 'name' : 'neobundle',
\ 'action_table': {},
\ 'parents' : ['uri', 'directory'],
\ 'default_action' : 'update',
\}
" Actions "{{{
let s:kind.action_table.update = {
\ 'description' : 'update bundles',
\ 'is_selectable' : 1,
\ 'is_start' : 1,
\ }
function! s:kind.action_table.update.func(candidates) abort "{{{
call unite#start_script([['neobundle/update', '!']
\ + map(copy(a:candidates), 'v:val.action__bundle_name')],
\ { 'log' : 1 })
endfunction"}}}
let s:kind.action_table.delete = {
\ 'description' : 'delete bundles',
\ 'is_invalidate_cache' : 1,
\ 'is_quit' : 0,
\ 'is_selectable' : 1,
\ }
function! s:kind.action_table.delete.func(candidates) abort "{{{
call call('neobundle#commands#clean', insert(map(copy(a:candidates),
\ 'v:val.action__bundle_name'), 0))
endfunction"}}}
let s:kind.action_table.reinstall = {
\ 'description' : 'reinstall bundles',
\ 'is_selectable' : 1,
\ }
function! s:kind.action_table.reinstall.func(candidates) abort "{{{
call neobundle#installer#reinstall(
\ map(copy(a:candidates), 'v:val.action__bundle'))
endfunction"}}}
let s:kind.action_table.preview = {
\ 'description' : 'view the plugin documentation',
\ 'is_quit' : 0,
\ }
function! s:kind.action_table.preview.func(candidate) abort "{{{
" Search help files.
let readme = get(split(globpath(
\ a:candidate.action__path, 'doc/*.?*', 1), '\n'), 0, '')
if readme == ''
" Search README files.
let readme = get(split(globpath(
\ a:candidate.action__path, 'README*', 1), '\n'), 0, '')
if readme == ''
return
endif
endif
let buflisted = buflisted(
\ unite#util#escape_file_searching(readme))
execute 'pedit' fnameescape(readme)
" Open folds.
normal! zv
normal! zt
if !buflisted
call unite#add_previewed_buffer_list(
\ bufnr(unite#util#escape_file_searching(readme)))
endif
endfunction"}}}
"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

143
.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle.vim Normal file
View file

@ -0,0 +1,143 @@
"=============================================================================
" FILE: neobundle.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! unite#sources#neobundle#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'neobundle',
\ 'description' : 'candidates from bundles',
\ 'hooks' : {},
\ }
function! s:source.hooks.on_init(args, context) abort "{{{
let bundle_names = filter(copy(a:args), 'v:val != "!"')
let a:context.source__bang =
\ index(a:args, '!') >= 0
let a:context.source__bundles = neobundle#util#sort_by(
\ (empty(bundle_names) ?
\ neobundle#config#get_neobundles() :
\ neobundle#config#search(bundle_names)),
\ 'tolower(v:val.orig_name)')
endfunction"}}}
" Filters "{{{
function! s:source.source__converter(candidates, context) abort "{{{
for candidate in a:candidates
if candidate.source__uri =~
\ '^\%(https\?\|git\)://github.com/'
let candidate.action__uri = candidate.source__uri
let candidate.action__uri =
\ substitute(candidate.action__uri, '^git://', 'https://', '')
let candidate.action__uri =
\ substitute(candidate.action__uri, '.git$', '', '')
endif
endfor
return a:candidates
endfunction"}}}
let s:source.converters = s:source.source__converter
"}}}
function! s:source.gather_candidates(args, context) abort "{{{
let _ = map(copy(a:context.source__bundles), "{
\ 'word' : substitute(v:val.orig_name,
\ '^\%(https\?\|git\)://\%(github.com/\)\?', '', ''),
\ 'kind' : 'neobundle',
\ 'action__path' : v:val.path,
\ 'action__directory' : v:val.path,
\ 'action__bundle' : v:val,
\ 'action__bundle_name' : v:val.name,
\ 'source__uri' : v:val.uri,
\ 'source__description' : v:val.description,
\ 'is_multiline' : 1,
\ }
\")
let max = max(map(copy(_), 'len(v:val.word)'))
call unite#print_source_message(
\ '#: not sourced, X: not installed', self.name)
for candidate in _
let candidate.abbr =
\ neobundle#is_sourced(candidate.action__bundle_name) ? ' ' :
\ neobundle#is_installed(candidate.action__bundle_name) ? '#' : 'X'
let candidate.abbr .= ' ' . unite#util#truncate(candidate.word, max)
if candidate.source__description != ''
let candidate.abbr .= ' : ' . candidate.source__description
endif
if a:context.source__bang
let status = s:get_commit_status(candidate.action__bundle)
if status != ''
let candidate.abbr .= "\n " . status
endif
endif
let candidate.word .= candidate.source__description
endfor
return _
endfunction"}}}
function! s:get_commit_status(bundle) abort "{{{
if !isdirectory(a:bundle.path)
return 'Not installed'
endif
let type = neobundle#config#get_types(a:bundle.type)
let cmd = has_key(type, 'get_revision_pretty_command') ?
\ type.get_revision_pretty_command(a:bundle) :
\ type.get_revision_number_command(a:bundle)
if cmd == ''
return ''
endif
let cwd = getcwd()
try
call neobundle#util#cd(a:bundle.path)
let output = neobundle#util#system(cmd)
finally
call neobundle#util#cd(cwd)
endtry
if neobundle#util#get_last_status()
return printf('Error(%d) occurred when executing "%s"',
\ neobundle#util#get_last_status(), cmd)
endif
return output
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

190
.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_install.vim Normal file
View file

@ -0,0 +1,190 @@
"=============================================================================
" FILE: neobundle/install.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! unite#sources#neobundle_install#define() abort "{{{
return [s:source_install, s:source_update]
endfunction"}}}
let s:source_install = {
\ 'name' : 'neobundle/install',
\ 'description' : 'install bundles',
\ 'hooks' : {},
\ 'default_kind' : 'word',
\ 'syntax' : 'uniteSource__NeoBundleInstall',
\ }
function! s:source_install.hooks.on_init(args, context) abort "{{{
let bundle_names = filter(copy(a:args), "v:val != '!'")
let a:context.source__bang =
\ index(a:args, '!') >= 0 || !empty(bundle_names)
let a:context.source__not_fuzzy = 0
call s:init(a:context, bundle_names)
endfunction"}}}
function! s:source_install.hooks.on_syntax(args, context) abort "{{{
syntax match uniteSource__NeoBundleInstall_Progress /(.\{-}):\s*.*/
\ contained containedin=uniteSource__NeoBundleInstall
highlight default link uniteSource__NeoBundleInstall_Progress String
syntax match uniteSource__NeoBundleInstall_Source /|.\{-}|/
\ contained containedin=uniteSource__NeoBundleInstall_Progress
highlight default link uniteSource__NeoBundleInstall_Source Type
syntax match uniteSource__NeoBundleInstall_URI /-> diff URI/
\ contained containedin=uniteSource__NeoBundleInstall
highlight default link uniteSource__NeoBundleInstall_URI Underlined
endfunction"}}}
function! s:source_install.hooks.on_close(args, context) abort "{{{
if !empty(a:context.source__processes)
for process in a:context.source__processes
if has('nvim')
call jobstop(process.proc)
else
call process.proc.waitpid()
endif
endfor
endif
endfunction"}}}
function! s:source_install.async_gather_candidates(args, context) abort "{{{
if !a:context.sync && empty(filter(range(1, winnr('$')),
\ "getwinvar(v:val, '&l:filetype') ==# 'unite'"))
return []
endif
let old_msgs = copy(neobundle#installer#get_updates_log())
if a:context.source__number < a:context.source__max_bundles
while a:context.source__number < a:context.source__max_bundles
\ && len(a:context.source__processes) <
\ g:neobundle#install_max_processes
let bundle = a:context.source__bundles[a:context.source__number]
call neobundle#installer#sync(bundle, a:context, 1)
call unite#clear_message()
call unite#print_source_message(
\ neobundle#installer#get_progress_message(bundle,
\ a:context.source__number,
\ a:context.source__max_bundles), self.name)
redrawstatus
endwhile
endif
if !empty(a:context.source__processes)
for process in a:context.source__processes
call neobundle#installer#check_output(a:context, process, 1)
endfor
" Filter eof processes.
call filter(a:context.source__processes, '!v:val.eof')
else
call neobundle#installer#update_log(
\ neobundle#installer#get_updated_bundles_message(
\ a:context.source__synced_bundles), 1)
call neobundle#installer#update_log(
\ neobundle#installer#get_errored_bundles_message(
\ a:context.source__errored_bundles), 1)
call neobundle#installer#update(
\ a:context.source__synced_bundles)
" Finish.
call neobundle#installer#update_log('Completed.', 1)
let a:context.is_async = 0
endif
return map(neobundle#installer#get_updates_log()[len(old_msgs) :], "{
\ 'word' : (v:val =~ '^\\s*\\h\\w*://' ? ' -> diff URI' : v:val),
\ 'is_multiline' : 1,
\ 'kind' : (v:val =~ '^\\s*\\h\\w*://' ? 'uri' : 'word'),
\ 'action__uri' : substitute(v:val, '^\\s\\+', '', ''),
\}")
endfunction"}}}
function! s:source_install.complete(args, context, arglead, cmdline, cursorpos) abort "{{{
return ['!'] +
\ neobundle#commands#complete_bundles(a:arglead, a:cmdline, a:cursorpos)
endfunction"}}}
let s:source_update = deepcopy(s:source_install)
let s:source_update.name = 'neobundle/update'
let s:source_update.description = 'update bundles'
function! s:source_update.hooks.on_init(args, context) abort "{{{
let a:context.source__bang =
\ index(a:args, 'all') >= 0 ? 2 : 1
let a:context.source__not_fuzzy = index(a:args, '!') >= 0
let bundle_names = filter(copy(a:args),
\ "v:val !=# 'all' && v:val !=# '!'")
call s:init(a:context, bundle_names)
endfunction"}}}
function! s:init(context, bundle_names) abort "{{{
let a:context.source__synced_bundles = []
let a:context.source__errored_bundles = []
let a:context.source__processes = []
let a:context.source__number = 0
let a:context.source__bundles = !a:context.source__bang ?
\ neobundle#get_force_not_installed_bundles(a:bundle_names) :
\ empty(a:bundle_names) ?
\ neobundle#config#get_enabled_bundles() :
\ a:context.source__not_fuzzy ?
\ neobundle#config#search(a:bundle_names) :
\ neobundle#config#fuzzy_search(a:bundle_names)
call neobundle#installer#_load_install_info(
\ a:context.source__bundles)
let reinstall_bundles =
\ neobundle#installer#get_reinstall_bundles(
\ a:context.source__bundles)
if !empty(reinstall_bundles)
call neobundle#installer#reinstall(reinstall_bundles)
endif
let a:context.source__max_bundles =
\ len(a:context.source__bundles)
call neobundle#installer#clear_log()
if empty(a:context.source__bundles)
let a:context.is_async = 0
call neobundle#installer#error(
\ 'Target bundles not found. You may use wrong bundle name.')
else
call neobundle#installer#update_log(
\ 'Update started: ' . strftime('(%Y/%m/%d %H:%M:%S)'))
endif
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

76
.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_lazy.vim Normal file
View file

@ -0,0 +1,76 @@
"=============================================================================
" FILE: neobundle_lazy.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! unite#sources#neobundle_lazy#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'neobundle/lazy',
\ 'description' : 'candidates from lazy bundles',
\ 'action_table' : {},
\ 'default_action' : 'source',
\ }
function! s:source.gather_candidates(args, context) abort "{{{
let _ = []
for bundle in filter(copy(neobundle#config#get_neobundles()),
\ '!v:val.sourced')
let name = substitute(bundle.orig_name,
\ '^\%(https\?\|git\)://\%(github.com/\)\?', '', '')
let dict = {
\ 'word' : name,
\ 'kind' : 'neobundle',
\ 'action__path' : bundle.path,
\ 'action__directory' : bundle.path,
\ 'action__bundle' : bundle,
\ 'action__bundle_name' : bundle.name,
\ 'source__uri' : bundle.uri,
\ }
call add(_, dict)
endfor
return _
endfunction"}}}
" Actions "{{{
let s:source.action_table.source = {
\ 'description' : 'source bundles',
\ 'is_selectable' : 1,
\ 'is_invalidate_cache' : 1,
\ }
function! s:source.action_table.source.func(candidates) abort "{{{
call call('neobundle#config#source',
\ map(copy(a:candidates), 'v:val.action__bundle_name'))
endfunction"}}}
"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

66
.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_log.vim Normal file
View file

@ -0,0 +1,66 @@
"=============================================================================
" FILE: neobundle/log.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
function! unite#sources#neobundle_log#define() abort "{{{
return s:source
endfunction"}}}
let s:source = {
\ 'name' : 'neobundle/log',
\ 'description' : 'print previous neobundle install logs',
\ 'syntax' : 'uniteSource__NeoBundleLog',
\ 'hooks' : {},
\ }
function! s:source.hooks.on_syntax(args, context) abort "{{{
syntax match uniteSource__NeoBundleLog_Message /.*/
\ contained containedin=uniteSource__NeoBundleLog
highlight default link uniteSource__NeoBundleLog_Message Comment
syntax match uniteSource__NeoBundleLog_Progress /(.\{-}):\s*.*/
\ contained containedin=uniteSource__NeoBundleLog
highlight default link uniteSource__NeoBundleLog_Progress String
syntax match uniteSource__NeoBundleLog_Source /|.\{-}|/
\ contained containedin=uniteSource__NeoBundleLog_Progress
highlight default link uniteSource__NeoBundleLog_Source Type
syntax match uniteSource__NeoBundleLog_URI /-> diff URI/
\ contained containedin=uniteSource__NeoBundleLog
highlight default link uniteSource__NeoBundleLog_URI Underlined
endfunction"}}}
function! s:source.gather_candidates(args, context) abort "{{{
return map(copy(neobundle#installer#get_log()), "{
\ 'word' : (v:val =~ '^\\s*\\h\\w*://' ? ' -> diff URI' : v:val),
\ 'kind' : (v:val =~ '^\\s*\\h\\w*://' ? 'uri' : 'word'),
\ 'action__uri' : substitute(v:val, '^\\s\\+', '', ''),
\ }")
endfunction"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

265
.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_search.vim Normal file
View file

@ -0,0 +1,265 @@
"=============================================================================
" FILE: neobundle_search.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
let s:Cache = unite#util#get_vital_cache()
function! unite#sources#neobundle_search#define() abort "{{{
" Init sources.
if !exists('s:neobundle_sources')
let s:neobundle_sources = {}
for define in map(split(globpath(&runtimepath,
\ 'autoload/neobundle/sources/*.vim', 1), '\n'),
\ "neobundle#sources#{fnamemodify(v:val, ':t:r')}#define()")
for dict in (type(define) == type([]) ? define : [define])
if !empty(dict) && !has_key(s:neobundle_sources, dict.name)
let s:neobundle_sources[dict.name] = dict
endif
endfor
unlet define
endfor
endif
return s:source
endfunction"}}}
let s:plugin_names = []
" Source rec.
let s:source = {
\ 'name' : 'neobundle/search',
\ 'description' : 'search plugins for neobundle',
\ 'hooks' : {},
\ 'action_table' : {},
\ 'default_action' : 'yank',
\ 'max_candidates' : 200,
\ 'syntax' : 'uniteSource__NeoBundleSearch',
\ 'parents' : ['uri'],
\ }
function! s:source.hooks.on_init(args, context) abort "{{{
let a:context.source__sources = copy(s:neobundle_sources)
if !empty(a:args)
let a:context.source__sources = filter(
\ a:context.source__sources,
\ 'index(a:args, v:key) >= 0')
endif
let a:context.source__input = a:context.input
if a:context.source__input == ''
let a:context.source__input =
\ unite#util#input('Please input search word: ', '',
\ 'customlist,unite#sources#neobundle_search#complete_plugin_names')
endif
endfunction"}}}
function! s:source.gather_candidates(args, context) abort "{{{
if neobundle#util#is_sudo()
call neobundle#util#print_error(
\ '"sudo vim" is detected. This feature is disabled.')
return []
endif
call unite#print_source_message('Search word: '
\ . a:context.source__input, s:source.name)
let candidates = []
let a:context.source__source_names = []
let s:plugin_names = []
for source in values(a:context.source__sources)
let source_candidates = source.gather_candidates(a:args, a:context)
let source_name = get(source, 'short_name', source.name)
for candidate in source_candidates
let candidate.source__source = source_name
if !has_key(candidate, 'source__script_type')
let candidate.source__script_type = ''
endif
if !has_key(candidate, 'source__description')
let candidate.source__description = ''
endif
endfor
let candidates += source_candidates
call add(a:context.source__source_names, source_name)
let s:plugin_names += map(copy(source_candidates), 'v:val.source__name')
endfor
call s:initialize_plugin_names(a:context)
return filter(candidates,
\ 'stridx(v:val.word, a:context.source__input) >= 0')
endfunction"}}}
function! s:source.complete(args, context, arglead, cmdline, cursorpos) abort "{{{
let arglead = get(a:args, -1, '')
return filter(keys(s:neobundle_sources),
\ "stridx(v:val, arglead) == 0")
endfunction"}}}
function! s:source.hooks.on_syntax(args, context) abort "{{{
syntax match uniteSource__NeoBundleSearch_DescriptionLine
\ / -- .*$/
\ contained containedin=uniteSource__NeoBundleSearch
syntax match uniteSource__NeoBundleSearch_Description
\ /.*$/
\ contained containedin=uniteSource__NeoBundleSearch_DescriptionLine
syntax match uniteSource__NeoBundleSearch_Marker
\ / -- /
\ contained containedin=uniteSource__NeoBundleSearch_DescriptionLine
syntax match uniteSource__NeoBundleSearch_Install
\ / Installed /
\ contained containedin=uniteSource__NeoBundleSearch
highlight default link uniteSource__NeoBundleSearch_Install Statement
highlight default link uniteSource__NeoBundleSearch_Marker Special
highlight default link uniteSource__NeoBundleSearch_Description Comment
endfunction"}}}
" Actions "{{{
let s:source.action_table.yank = {
\ 'description' : 'yank plugin settings',
\ 'is_selectable' : 1,
\ }
function! s:source.action_table.yank.func(candidates) abort "{{{
let @" = join(map(a:candidates,
\ "'NeoBundle ' . s:get_neobundle_args(v:val)"), "\n")
if has('clipboard')
call setreg(v:register, @")
endif
echo 'Yanked plugin settings!'
endfunction"}}}
let s:source.action_table.install = {
\ 'description' : 'direct install plugins',
\ 'is_selectable' : 1,
\ 'is_quit' : 0,
\ }
function! s:source.action_table.install.func(candidates) abort "{{{
for candidate in a:candidates
execute 'NeoBundleDirectInstall' s:get_neobundle_args(candidate)
endfor
endfunction"}}}
"}}}
" Filters "{{{
function! s:source.source__sorter(candidates, context) abort "{{{
return s:sort_by(a:candidates, 'v:val.source__name')
endfunction"}}}
function! s:source.source__converter(candidates, context) abort "{{{
let max_plugin_name = max(map(copy(a:candidates),
\ 'len(v:val.source__name)'))
let max_script_type = max(map(copy(a:candidates),
\ 'len(v:val.source__script_type)'))
let max_source_name = max(map(copy(a:context.source__source_names),
\ 'len(v:val)'))
let format = '%-'. max_plugin_name .'s %-'.
\ max_source_name .'s %-'. max_script_type .'s -- %s'
for candidate in a:candidates
let candidate.abbr = printf(format,
\ candidate.source__name, candidate.source__source,
\ candidate.source__script_type,
\ (neobundle#is_installed(candidate.source__name) ?
\ 'Installed' : candidate.source__description))
let candidate.is_multiline = 1
let candidate.kind =
\ get(candidate, 'action__path', '') != '' ?
\ 'file' : 'common'
endfor
return a:candidates
endfunction"}}}
let s:source.sorters = s:source.source__sorter
let s:source.converters = s:source.source__converter
"}}}
" Misc. "{{{
function! s:sort_by(list, expr) abort
let pairs = map(a:list, printf('[v:val, %s]', a:expr))
return map(s:sort(pairs,
\ 'a:a[1] == a:b[1] ? 0 : a:a[1] > a:b[1] ? 1 : -1'), 'v:val[0]')
endfunction
" Sorts a list with expression to compare each two values.
" a:a and a:b can be used in {expr}.
function! s:sort(list, expr) abort
if type(a:expr) == type(function('function'))
return sort(a:list, a:expr)
endif
let s:expr = a:expr
return sort(a:list, 's:_compare')
endfunction
function! s:_compare(a, b) abort
return eval(s:expr)
endfunction
function! s:get_neobundle_args(candidate) abort
return string(substitute(a:candidate.source__path,
\ '^https://github.com/', '', ''))
\ . (empty(a:candidate.source__options) ?
\ '' : ', ' . string(a:candidate.source__options))
\ . (a:candidate.source__description == '' ? '' :
\ ' " ' . a:candidate.source__description)
endfunction
function! unite#sources#neobundle_search#complete_plugin_names(arglead, cmdline, cursorpos) abort "{{{
return filter(s:get_plugin_names(), "stridx(v:val, a:arglead) == 0")
endfunction"}}}
function! s:initialize_plugin_names(context) abort "{{{
let cache_dir = neobundle#get_neobundle_dir() . '/.neobundle'
let path = 'plugin_names'
if a:context.is_redraw || !s:Cache.filereadable(cache_dir, path)
" Convert cache data.
call s:Cache.writefile(cache_dir, path, [string(s:plugin_names)])
endif
return s:get_plugin_names()
endfunction"}}}
function! s:get_plugin_names() abort "{{{
let cache_dir = neobundle#get_neobundle_dir() . '/.neobundle'
let path = 'plugin_names'
if empty(s:plugin_names) && s:Cache.filereadable(cache_dir, path)
sandbox let s:plugin_names =
\ eval(get(s:Cache.readfile(cache_dir, path), 0, '[]'))
endif
return neobundle#util#uniq(s:plugin_names)
endfunction"}}}
"}}}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim: foldmethod=marker

137
.vim/bundle/neobundle.vim/bin/install.sh Executable file
View file

@ -0,0 +1,137 @@
#!/bin/sh
# Standalone installer for Unixs
# Original version is created by shoma2da
# https://github.com/shoma2da/neobundle_installer
# Installation directory
BUNDLE_DIR=~/.vim/bundle
INSTALL_DIR="$BUNDLE_DIR/neobundle.vim"
echo "$INSTALL_DIR"
if [ -e "$INSTALL_DIR" ]; then
echo "$INSTALL_DIR already exists!"
fi
NVIM_DIR=~/.config/nvim
NVIM_BUNDLE_DIR="$NVIM_DIR/bundle"
NVIM_INSTALL_DIR="$NVIM_BUNDLE_DIR/neobundle.vim"
echo "$NVIM_INSTALL_DIR"
if [ -e "$NVIM_INSTALL_DIR" ]; then
echo "$NVIM_INSTALL_DIR already exists!"
fi
if [ -e "$INSTALL_DIR" ] && [ -e "$NVIM_INSTALL_DIR" ]; then
exit 1
fi
# check git command
if type git; then
: # You have git command. No Problem.
else
echo 'Please install git or update your path to include the git executable!'
exit 1
fi
# make bundle dir and fetch neobundle
echo "Begin fetching NeoBundle..."
if ! [ -e "$INSTALL_DIR" ]; then
mkdir -p "$BUNDLE_DIR"
git clone https://github.com/Shougo/neobundle.vim "$INSTALL_DIR"
fi
if type nvim > /dev/null 2>&1 && ! [ -e "$NVIM_INSTALL_DIR" ]; then
mkdir -p "$NVIM_BUNDLE_DIR"
git clone https://github.com/Shougo/neobundle.vim "$NVIM_INSTALL_DIR"
fi
echo "Done."
# write initial setting for .vimrc
echo "Please add the following settings for NeoBundle to the top of your .vimrc file:"
{
echo ""
echo ""
echo "\"NeoBundle Scripts-----------------------------"
echo "if &compatible"
echo " set nocompatible \" Be iMproved"
echo "endif"
echo ""
echo "\" Required:"
echo "set runtimepath+=$BUNDLE_DIR/neobundle.vim/"
echo ""
echo "\" Required:"
echo "call neobundle#begin(expand('$BUNDLE_DIR'))"
echo ""
echo "\" Let NeoBundle manage NeoBundle"
echo "\" Required:"
echo "NeoBundleFetch 'Shougo/neobundle.vim'"
echo ""
echo "\" Add or remove your Bundles here:"
echo "NeoBundle 'Shougo/neosnippet.vim'"
echo "NeoBundle 'Shougo/neosnippet-snippets'"
echo "NeoBundle 'tpope/vim-fugitive'"
echo "NeoBundle 'ctrlpvim/ctrlp.vim'"
echo "NeoBundle 'flazz/vim-colorschemes'"
echo ""
echo "\" You can specify revision/branch/tag."
echo "NeoBundle 'Shougo/vimshell', { 'rev' : '3787e5' }"
echo ""
echo "\" Required:"
echo "call neobundle#end()"
echo ""
echo "\" Required:"
echo "filetype plugin indent on"
echo ""
echo "\" If there are uninstalled bundles found on startup,"
echo "\" this will conveniently prompt you to install them."
echo "NeoBundleCheck"
echo "\"End NeoBundle Scripts-------------------------"
echo ""
echo ""
}
# write initial setting for ~/.config/nvim/init.vim
if type nvim > /dev/null 2>&1; then
echo "Please add the following settings for NeoBundle to the top of your init.vim file:"
{
echo ""
echo ""
echo "\"NeoBundle Scripts-----------------------------"
echo "if has('vim_starting')"
echo " \" Required:"
echo " set runtimepath+=$NVIM_BUNDLE_DIR/neobundle.vim/"
echo "endif"
echo ""
echo "\" Required:"
echo "call neobundle#begin(expand('$NVIM_BUNDLE_DIR'))"
echo ""
echo "\" Let NeoBundle manage NeoBundle"
echo "\" Required:"
echo "NeoBundleFetch 'Shougo/neobundle.vim'"
echo ""
echo "\" Add or remove your Bundles here:"
echo "NeoBundle 'Shougo/neosnippet.vim'"
echo "NeoBundle 'Shougo/neosnippet-snippets'"
echo "NeoBundle 'tpope/vim-fugitive'"
echo "NeoBundle 'ctrlpvim/ctrlp.vim'"
echo "NeoBundle 'flazz/vim-colorschemes'"
echo ""
echo "\" You can specify revision/branch/tag."
echo "NeoBundle 'Shougo/vimshell', { 'rev' : '3787e5' }"
echo ""
echo "\" Required:"
echo "call neobundle#end()"
echo ""
echo "\" Required:"
echo "filetype plugin indent on"
echo ""
echo "\" If there are uninstalled bundles found on startup,"
echo "\" this will conveniently prompt you to install them."
echo "NeoBundleCheck"
echo "\"End NeoBundle Scripts-------------------------"
echo ""
echo ""
}
fi
echo "Done."
echo "Complete setup NeoBundle!"

12
.vim/bundle/neobundle.vim/bin/neoinstall Executable file
View file

@ -0,0 +1,12 @@
#!/bin/sh
# Detect .vimrc path.
VIMRC=$HOME/.vimrc
if [ ! -e $VIMRC ]; then
VIMRC=$HOME/.vim/vimrc
fi
vim -N -u $VIMRC -c "try | NeoBundleUpdate! $* | finally | qall! | endtry" \
-U NONE -i NONE -V1 -e -s
echo ''

30
.vim/bundle/neobundle.vim/bin/neoinstall.bat Normal file
View file

@ -0,0 +1,30 @@
@echo off
for /F "usebackq" %%t in (`where vim`) do SET _VIM=%%t
set VIM=%_VIM:\vim.exe=%
if "%HOME%"=="" set HOME=%USERPROFILE%
set _VIMRC=%HOME%\_vimrc
if exist %_VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %_VIMRC% goto DOTVIMRC
:DOTVIMRC
set VIMRC=%HOME%\.vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto VIMFILES
:VIMFILES
set VIMRC=%HOME%\vimfiles\vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto ORIGIN_VIM
:ORIGIN_VIM
set VIMRC=%VIM%\_vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto NO_EXEC_NEOBUNDLE_INSTALL
@echo on
:EXEC_NEOBUNDLE_INSTALL
vim -N -u %VIMRC% -c "try | NeoBundleUpdate! %* | finally | qall! | endtry" -U NONE -i NONE -V1 -e -s
:NO_EXEC_NEOBUNDLE_INSTALL
echo 'vimrc is NotFound.'

30
.vim/bundle/neobundle.vim/bin/neoinstall_novimproc.bat Normal file
View file

@ -0,0 +1,30 @@
@echo off
for /F "usebackq" %%t in (`where vim`) do SET _VIM=%%t
set VIM=%_VIM:\vim.exe=%
if "%HOME%"=="" set HOME=%USERPROFILE%
set _VIMRC=%HOME%\_vimrc
if exist %_VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %_VIMRC% goto DOTVIMRC
:DOTVIMRC
set VIMRC=%HOME%\.vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto VIMFILES
:VIMFILES
set VIMRC=%HOME%\vimfiles\vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto ORIGIN_VIM
:ORIGIN_VIM
set VIMRC=%VIM%\_vimrc
if exist %VIMRC% goto EXEC_NEOBUNDLE_INSTALL
if not exist %VIMRC% goto NO_EXEC_NEOBUNDLE_INSTALL
@echo on
:EXEC_NEOBUNDLE_INSTALL
vim -N -u %VIMRC% --cmd "let g:vimproc#disable = 1" -c "try | NeoBundleUpdate! %* | finally | qall! | endtry" -U NONE -i NONE -V1 -e -s
:NO_EXEC_NEOBUNDLE_INSTALL
echo 'vimrc is NotFound.'

1753
.vim/bundle/neobundle.vim/doc/neobundle.txt Normal file
View file

File diff suppressed because it is too large Load diff

60
.vim/bundle/neobundle.vim/plugin/neobundle.vim Normal file
View file

@ -0,0 +1,60 @@
"=============================================================================
" FILE: neobundle.vim
" AUTHOR: Shougo Matsushita <Shougo.Matsu@gmail.com>
" License: MIT license {{{
" Permission is hereby granted, free of charge, to any person obtaining
" a copy of this software and associated documentation files (the
" "Software"), to deal in the Software without restriction, including
" without limitation the rights to use, copy, modify, merge, publish,
" distribute, sublicense, and/or sell copies of the Software, and to
" permit persons to whom the Software is furnished to do so, subject to
" the following conditions:
"
" The above copyright notice and this permission notice shall be included
" in all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
" IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
" CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
" TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
" SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
" }}}
"=============================================================================
let s:save_cpo = &cpo
set cpo&vim
if exists('g:loaded_neobundle')
let &cpo = s:save_cpo
unlet s:save_cpo
finish
elseif v:version < 702 || (v:version == 702 && !has('patch51'))
" Neobundle uses glob()/globpath() another parameter.
" It is implemented in Vim 7.2.051.
echoerr 'neobundle does not work this version of Vim "' . v:version . '".'
\ .' You must use Vim 7.2.051 or later.'
let &cpo = s:save_cpo
unlet s:save_cpo
finish
elseif fnamemodify(&shell, ':t') ==# 'fish' && !has('patch-7.4.276')
echoerr 'Vim does not support "' . &shell . '".'
\ .' You must use Vim 7.4.276 or later.'
let &cpo = s:save_cpo
unlet s:save_cpo
finish
endif
let g:loaded_neobundle = 1
let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: foldmethod=marker

117
.vim/bundle/neobundle.vim/test/commands.vim Normal file
View file

@ -0,0 +1,117 @@
" Basic commands test.
set verbose=1
let path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
if isdirectory(path)
let rm_command = neobundle#util#is_windows() ? 'rmdir /S /Q' : 'rm -rf'
call system(printf('%s "%s"', rm_command, path))
endif
call mkdir(path, 'p')
call neobundle#begin(path)
let g:neobundle#types#git#default_protocol = 'https'
" My Bundles here:
"
" Original repositories in github.
NeoBundle 'Shougo/neocomplcache-clang.git'
" Vim-script repositories.
NeoBundle 'rails.vim'
" Username with dashes.
NeoBundle 'vim-scripts/ragtag.vim'
" Original repo.
NeoBundle 'altercation/vim-colors-solarized'
" With extension.
" Comment is allowed.
NeoBundle 'nelstrom/vim-mac-classic-theme.git' " Foo, Bar
" Invalid uri.
NeoBundle 'nonexistinguser/hogehoge.git'
" Full uri.
NeoBundle 'https://github.com/vim-scripts/vim-game-of-life'
NeoBundle 'git@github.com:gmarik/ingretu.git'
" Short uri.
NeoBundle 'gh:gmarik/snipmate.vim.git'
NeoBundle 'github:mattn/gist-vim.git'
" Camel case.
NeoBundle 'vim-scripts/RubySinatra'
" With options.
NeoBundle 'Shougo/vimshell', '3787e5'
" None repos.
NeoBundle 'muttator', {'type' : 'none', 'base' : '~/.vim/bundle'}
" Raw repos.
NeoBundle 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim',
\ {'script_type' : 'plugin'}
" NeoBundleLocal test.
NeoBundleLocal ~/.vim/bundle/
" Depends repos.
NeoBundle 'Shougo/neocomplcache',
\ {'depends' : [
\ 'Shougo/neocomplcache-snippets-complete.git',
\ ['rstacruz/sparkup', {'rtp': 'vim'}],
\ ]}
NeoBundle 'Shougo/vimfiler',
\ { 'depends' : 'Shougo/unite.vim' }
" Build repos.
NeoBundle 'Shougo/vimproc', {
\ 'build' : {
\ 'windows' : 'echo "Sorry, cannot update vimproc binary file in Windows."',
\ 'cygwin' : 'make -f make_cygwin.mak',
\ 'mac' : 'make -f make_mac.mak',
\ 'unix' : 'make -f make_unix.mak',
\ },
\ }
" Lazy load.
NeoBundleLazy 'c9s/perlomni.vim.git'
NeoBundleSource perlomni.vim
call neobundle#source(['CSApprox'])
NeoBundleLazy 'The-NERD-tree', {'augroup' : 'NERDTree'}
call neobundle#source(['The-NERD-tree'])
NeoBundleLazy 'masudaK/vim-python'
NeoBundleLazy 'klen/python-mode'
NeoBundleLazy 'Rip-Rip/clang_complete', {
\ 'autoload' : {
\ 'filetypes' : ['c', 'cpp'],
\ },
\ }
" script_type support.
NeoBundle 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim',
\ {'script_type' : 'plugin'}
" Fetch only.
NeoBundleFetch 'Shougo/neobundle.vim'
call neobundle#end()
filetype plugin indent on " required!
" Should not break helptags.
set wildignore+=doc
" Should not break clone.
set wildignore+=.git
set wildignore+=.git/*
set wildignore+=*/.git/*

35
.vim/bundle/neobundle.vim/test/lock.vim Normal file
View file

@ -0,0 +1,35 @@
" Lock file test.
set verbose=1
let path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
if isdirectory(path)
let rm_command = neobundle#util#is_windows() ? 'rmdir /S /Q' : 'rm -rf'
call system(printf('%s "%s"', rm_command, path))
endif
call mkdir(path, 'p')
call neobundle#begin(path)
NeoBundleFetch 'Shougo/neocomplete.vim'
call neobundle#end()
filetype plugin indent on " Required!
" Create lock file
call writefile([
\ 'NeoBundleLock neocomplete.vim 8200dfd83ba829f77f028ea26e81eebbe95e6a89',
\ ], path . '/NeoBundle.lock')
NeoBundleInstall
let s:suite = themis#suite('lock')
let s:assert = themis#helper('assert')
function! s:suite.revision_check() abort
let bundle = neobundle#get('neocomplete.vim')
call s:assert.equals(neobundle#installer#get_revision_number(bundle),
\ '8200dfd83ba829f77f028ea26e81eebbe95e6a89')
endfunction

333
.vim/bundle/neobundle.vim/test/parse.vim Normal file
View file

@ -0,0 +1,333 @@
let s:suite = themis#suite('parser')
let s:assert = themis#helper('assert')
let g:neobundle#types#git#default_protocol = 'https'
let g:neobundle#types#hg#default_protocol = 'https'
let g:neobundle#enable_name_conversion = 0
function! s:suite.github_git_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'Shougo/neocomplcache-clang.git'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/Shougo/neocomplcache-clang.git',
\ 'name' : 'neocomplcache-clang'})
call s:assert.equals(neobundle#parser#path('Shougo/vimshell'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/Shougo/vimshell.git',
\ 'name' : 'vimshell'})
call s:assert.equals(neobundle#parser#path('rails.vim'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/vim-scripts/rails.vim.git',
\ 'name' : 'rails.vim'})
call s:assert.equals(neobundle#parser#path('vim-scripts/ragtag.vim'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/vim-scripts/ragtag.vim.git',
\ 'name' : 'ragtag.vim'})
call s:assert.equals(neobundle#parser#path(
\ 'https://github.com/vim-scripts/vim-game-of-life'),
\ {'type' : 'git', 'uri' :
\ 'https://github.com/vim-scripts/vim-game-of-life.git',
\ 'name' : 'vim-game-of-life'})
call s:assert.equals(neobundle#parser#path(
\ 'git@github.com:gmarik/ingretu.git'),
\ {'type' : 'git', 'uri' :
\ 'git@github.com:gmarik/ingretu.git',
\ 'name' : 'ingretu'})
call s:assert.equals(neobundle#parser#path(
\ 'gh:gmarik/snipmate.vim.git'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/gmarik/snipmate.vim.git',
\ 'name' : 'snipmate.vim'})
call s:assert.equals(neobundle#parser#path(
\ 'github:mattn/gist-vim.git'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol .
\ '://github.com/mattn/gist-vim.git',
\ 'name' : 'gist-vim'})
call s:assert.equals(neobundle#parser#path(
\ 'git@github.com:Shougo/neocomplcache.git'),
\ {'type' : 'git', 'uri' :
\ 'git@github.com:Shougo/neocomplcache.git',
\ 'name' : 'neocomplcache'})
call s:assert.equals(neobundle#parser#path(
\ 'https://github.com/Shougo/neocomplcache/'),
\ {'type' : 'git', 'uri' :
\ 'https://github.com/Shougo/neocomplcache.git',
\ 'name' : 'neocomplcache'})
call s:assert.equals(neobundle#parser#path(
\ 'git://git.wincent.com/command-t.git'),
\ {})
call s:assert.equals(neobundle#parser#path(
\ 'http://github.com/Shougo/neocomplcache/'),
\ {})
endfunction
function! s:suite.svn_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'http://svn.macports.org/repository/macports/contrib/mpvim/'),
\ {})
call s:assert.equals(neobundle#parser#path(
\ 'svn://user@host/repos/bar'),
\ {})
call s:assert.equals(neobundle#parser#path(
\ 'https://svn.macports.org/repository/macports/contrib/mpvim/'),
\ {'type' : 'svn', 'uri' :
\ 'https://svn.macports.org/repository/macports/contrib/mpvim',
\ 'name' : 'mpvim'})
call s:assert.equals(neobundle#parser#path(
\ 'svn+ssh://user@host/repos/bar'),
\ {'type' : 'svn', 'uri' :
\ 'svn+ssh://user@host/repos/bar',
\ 'name' : 'bar'})
endfunction
function! s:suite.hg_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'https://bitbucket.org/ns9tks/vim-fuzzyfinder'),
\ {'type' : 'hg', 'uri' :
\ 'https://bitbucket.org/ns9tks/vim-fuzzyfinder',
\ 'name' : 'vim-fuzzyfinder'})
call s:assert.equals(neobundle#parser#path(
\ 'bitbucket://bitbucket.org/ns9tks/vim-fuzzyfinder'),
\ {'type' : 'hg', 'uri' :
\ g:neobundle#types#hg#default_protocol.
\ '://bitbucket.org/ns9tks/vim-fuzzyfinder',
\ 'name' : 'vim-fuzzyfinder'})
call s:assert.equals(neobundle#parser#path(
\ 'bitbucket:ns9tks/vim-fuzzyfinder'),
\ {'type' : 'hg', 'uri' :
\ g:neobundle#types#hg#default_protocol.
\ '://bitbucket.org/ns9tks/vim-fuzzyfinder',
\ 'name' : 'vim-fuzzyfinder'})
call s:assert.equals(neobundle#parser#path(
\ 'ns9tks/vim-fuzzyfinder', {'site': 'bitbucket'}),
\ {'type' : 'hg', 'uri' :
\ g:neobundle#types#hg#default_protocol.
\ '://bitbucket.org/ns9tks/vim-fuzzyfinder',
\ 'name' : 'vim-fuzzyfinder'})
call s:assert.equals(neobundle#parser#path(
\ 'ssh://hg@bitbucket.org/ns9tks/vim-fuzzyfinder'),
\ {'type' : 'hg', 'uri' :
\ 'ssh://hg@bitbucket.org/ns9tks/vim-fuzzyfinder',
\ 'name' : 'vim-fuzzyfinder'})
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'type' : 'hg'}])
call s:assert.equals(bundle.name, 'neobundle.vim')
call s:assert.equals(bundle.type, 'hg')
call s:assert.equals(bundle.uri,
\ 'https://github.com/Shougo/neobundle.vim.git')
endfunction
function! s:suite.gitbucket_git_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'https://bitbucket.org/kh3phr3n/vim-qt-syntax.git'),
\ {'type' : 'git', 'uri' :
\ 'https://bitbucket.org/kh3phr3n/vim-qt-syntax.git',
\ 'name' : 'vim-qt-syntax'})
call s:assert.equals(neobundle#parser#path(
\ 'bitbucket:kh3phr3n/vim-qt-syntax.git'),
\ {'type' : 'git', 'uri' :
\ g:neobundle#types#git#default_protocol.
\ '://bitbucket.org/kh3phr3n/vim-qt-syntax.git',
\ 'name' : 'vim-qt-syntax'})
call s:assert.equals(neobundle#parser#path(
\ 'git@bitbucket.com:accountname/reponame.git'),
\ {'type' : 'git', 'uri' :
\ 'git@bitbucket.com:accountname/reponame.git',
\ 'name' : 'reponame'})
call s:assert.equals(neobundle#parser#path(
\ 'ssh://git@bitbucket.com:foo/bar.git'),
\ {'type' : 'git', 'uri' :
\ 'ssh://git@bitbucket.com:foo/bar.git',
\ 'name' : 'bar'})
endfunction
function! s:suite.raw_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'http://raw.github.com/m2ym/rsense/master/etc/rsense.vim'),
\ {})
call s:assert.equals(neobundle#parser#path(
\ 'http://www.vim.org/scripts/download_script.php?src_id=19237'),
\ {})
let bundle = neobundle#parser#_init_bundle(
\ 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim',
\ [{ 'script_type' : 'plugin'}])
call s:assert.equals(bundle.name, 'rsense.vim')
call s:assert.equals(bundle.type, 'raw')
call s:assert.equals(bundle.uri,
\ 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim')
endfunction
function! s:suite.vba_repos() abort
call s:assert.equals(neobundle#parser#path(
\ 'https://foo/bar.vba'),
\ { 'name' : 'bar', 'uri' : 'https://foo/bar.vba', 'type' : 'vba' })
call s:assert.equals(neobundle#parser#path(
\ 'https://foo/bar.vba.gz'),
\ { 'name' : 'bar', 'uri' : 'https://foo/bar.vba.gz', 'type' : 'vba' })
call s:assert.equals(neobundle#parser#path(
\ 'http://foo/bar.vba.gz'),
\ {})
endfunction
function! s:suite.default_options() abort
let g:default_options_save = g:neobundle#default_options
let g:neobundle#default_options =
\ { 'rev' : {'type__update_style' : 'current'},
\ '_' : {'type' : 'hg'} }
let bundle = neobundle#parser#_init_bundle(
\ 'Shougo/neocomplcache', ['', 'rev', {}])
call s:assert.equals(bundle.type__update_style, 'current')
let bundle2 = neobundle#parser#_init_bundle(
\ 'Shougo/neocomplcache', [])
call s:assert.equals(bundle2.type, 'hg')
let g:neobundle#default_options = g:default_options_save
endfunction
function! s:suite.ssh_protocol() abort
let bundle = neobundle#parser#_init_bundle(
\ 'accountname/reponame', [{
\ 'site' : 'github', 'type' : 'git', 'type__protocol' : 'ssh' }])
call s:assert.equals(bundle.uri,
\ 'git@github.com:accountname/reponame.git')
let bundle = neobundle#parser#_init_bundle(
\ 'accountname/reponame', [{
\ 'site' : 'bitbucket', 'type' : 'hg', 'type__protocol' : 'ssh' }])
call s:assert.equals(bundle.uri,
\ 'ssh://hg@bitbucket.org/accountname/reponame')
let bundle = neobundle#parser#_init_bundle(
\ 'accountname/reponame.git', [{
\ 'site' : 'bitbucket', 'type' : 'git', 'type__protocol' : 'ssh' }])
call s:assert.equals(bundle.uri,
\ 'git@bitbucket.org:accountname/reponame.git')
endfunction
function! s:suite.fetch_plugins() abort
let bundle = neobundle#parser#fetch(
\ string('accountname/reponame.git'))
call s:assert.equals(bundle.rtp, '')
endfunction
function! s:suite.parse_directory() abort
let bundle = neobundle#parser#_init_bundle(
\ 'Shougo/neocomplcache', [])
call s:assert.equals(bundle.directory, 'neocomplcache')
let bundle = neobundle#parser#_init_bundle(
\ 'Shougo/neocomplcache', ['ver.3'])
call s:assert.equals(bundle.directory, 'neocomplcache_ver_3')
endfunction
function! s:suite.name_conversion() abort
let g:neobundle#enable_name_conversion = 1
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'type' : 'hg'}])
call s:assert.equals(bundle.name, 'neobundle')
let bundle = neobundle#parser#_init_bundle(
\ 'https://bitbucket.org/kh3phr3n/vim-qt-syntax.git',
\ [{ 'type' : 'hg'}])
call s:assert.equals(bundle.name, 'qt-syntax')
let bundle = neobundle#parser#_init_bundle(
\ 'https://bitbucket.org/kh3phr3n/qt-syntax-vim.git',
\ [{ 'type' : 'hg'}])
call s:assert.equals(bundle.name, 'qt-syntax')
let bundle = neobundle#parser#_init_bundle(
\ 'https://bitbucket.org/kh3phr3n/vim-qt-syntax.git',
\ [{ 'name' : 'vim-qt-syntax'}])
call s:assert.equals(bundle.name, 'vim-qt-syntax')
let g:neobundle#enable_name_conversion = 0
endfunction
function! s:suite.autoload() abort
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'filetypes' : 'foo_ft' }])
call s:assert.equals(bundle.on_ft, ['foo_ft'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'filename_patterns' : 'foo_filename' }])
call s:assert.equals(bundle.on_path, ['foo_filename'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'explorer' : 1 }])
call s:assert.equals(bundle.on_path, ['.*'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'commands' : 'Foo' }])
call s:assert.equals(bundle.on_cmd, ['Foo'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'functions' : 'foo#bar' }])
call s:assert.equals(bundle.on_func, ['foo#bar'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'mappings' : '<Plug>' }])
call s:assert.equals(bundle.on_map, ['<Plug>'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'insert' : 1 }])
call s:assert.equals(bundle.on_i, 1)
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'on_source' : 'plug_foo' }])
call s:assert.equals(bundle.on_source, ['plug_foo'])
call s:assert.equals(bundle.lazy, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'command_prefix' : 'PreFoo' }])
call s:assert.equals(bundle.pre_cmd, ['PreFoo'])
call s:assert.equals(bundle.lazy, 0)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'function_prefixes' : 'foo#' }])
call s:assert.equals(bundle.pre_func, ['foo#'])
call s:assert.equals(bundle.lazy, 0)
endfunction
function! s:suite.deprecated() abort
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'stay_same' : '1' }])
call s:assert.equals(bundle.frozen, 1)
let bundle = neobundle#parser#_init_bundle(
\ 'https://github.com/Shougo/neobundle.vim.git',
\ [{ 'type' : 'nosync' }])
call s:assert.equals(bundle.type, 'none')
endfunction
" vim:foldmethod=marker:fen:

39
.vim/bundle/neobundle.vim/test/sample.vim Normal file
View file

@ -0,0 +1,39 @@
" Sample configurations test.
set verbose=1
let path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
if isdirectory(path)
let rm_command = neobundle#util#is_windows() ? 'rmdir /S /Q' : 'rm -rf'
call system(printf('%s "%s"', rm_command, path))
endif
let neobundle#types#git#default_protocol = 'git'
call neobundle#begin(path)
" Let NeoBundle manage NeoBundle
NeoBundleFetch 'Shougo/neobundle.vim'
" Recommended to install
" After install, turn shell ~/.vim/bundle/vimproc, (n,g)make -f your_machines_makefile
NeoBundle 'Shougo/vimproc'
" My Bundles here:
"
" Note: You don't set neobundle setting in .gvimrc!
" Original repos on github
NeoBundle 'tpope/vim-fugitive'
NeoBundle 'Lokaltog/vim-easymotion'
NeoBundle 'rstacruz/sparkup', {'rtp': 'vim/'}
" vim-scripts repos
NeoBundle 'L9'
NeoBundle 'FuzzyFinder'
NeoBundle 'rails.vim'
" Non git repos
NeoBundle 'https://bitbucket.org/ns9tks/vim-fuzzyfinder'
call neobundle#end()
filetype plugin indent on " Required!

95
.vim/bundle/neobundle.vim/test/source.vim Normal file
View file

@ -0,0 +1,95 @@
" Source test.
set verbose=1
let path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
if isdirectory(path)
let rm_command = neobundle#util#is_windows() ? 'rmdir /S /Q' : 'rm -rf'
call system(printf('%s "%s"', rm_command, path))
endif
let neobundle#types#git#default_protocol = 'https'
call neobundle#begin(path)
" Test dependencies.
let s:suite = themis#suite('source')
let s:assert = themis#helper('assert')
NeoBundleLazy 'Shougo/echodoc'
NeoBundle 'Shougo/unite-build', { 'depends' : 'Shougo/echodoc' }
NeoBundle 'Shougo/unite-ssh', { 'depends' : 'Shougo/unite-sudo' }
NeoBundleLazy 'Shougo/unite-sudo'
NeoBundleLazy 'Shougo/neomru.vim', { 'depends': 'Shougo/neocomplcache' }
NeoBundle 'Shougo/neocomplcache.vim', 'ver.8'
NeoBundleLazy 'Shougo/vimshell', { 'depends': 'Shougo/vinarise' }
NeoBundleLazy 'Shougo/vinarise'
NeoBundle 'Shougo/vimfiler', { 'depends' : 'foo/var' }
NeoBundleLazy 'Shougo/unite.vim', {
\ 'depends' : ['Shougo/unite-outline', 'basyura/TweetVim'],
\ 'autoload' : { 'commands' : 'Unite' } }
NeoBundleLazy 'Shougo/unite-outline', {
\ 'depends' : 'Shougo/unite.vim' }
" Dependencies test.
NeoBundleLazy 'basyura/twibill.vim'
NeoBundleLazy 'yomi322/neco-tweetvim'
NeoBundleLazy 'rhysd/tweetvim-advanced-filter'
NeoBundleLazy 'rhysd/TweetVim', {
\ 'depends' :
\ ['basyura/twibill.vim',
\ 'tyru/open-browser.vim',
\ 'yomi322/neco-tweetvim',
\ 'rhysd/tweetvim-advanced-filter'],
\ 'autoload' : {
\ 'commands' :
\ ['TweetVimHomeTimeline',
\ 'TweetVimMentions',
\ 'TweetVimSay',
\ 'TweetVimUserTimeline']
\ }
\ }
" Law.
NeoBundle 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim',
\ {'script_type' : 'plugin', 'rev' : '0'}
" NeoBundleReinstall rsense.vim
call neobundle#end()
filetype plugin indent on " required!
" Should not break helptags.
set wildignore+=doc
" Should not break clone.
set wildignore+=.git
set wildignore+=.git/*
set wildignore+=*/.git/*
function! s:suite.pattern_a() abort
call s:assert.equals(neobundle#is_sourced('echodoc'), 1)
call s:assert.equals(neobundle#is_sourced('unite-build'), 1)
endfunction
function! s:suite.pattern_b() abort
call s:assert.equals(neobundle#is_sourced('unite-ssh'), 1)
call s:assert.equals(neobundle#is_sourced('unite-sudo'), 1)
endfunction
function! s:suite.pattern_c() abort
call s:assert.equals(neobundle#is_sourced('neomru.vim'), 0)
call s:assert.equals(neobundle#is_sourced('neocomplcache.vim'), 1)
endfunction
function! s:suite.pattern_d() abort
call s:assert.equals(neobundle#is_sourced('vimshell'), 0)
call s:assert.equals(neobundle#is_sourced('vinarise'), 0)
endfunction

49
.vim/bundle/neobundle.vim/test/toml.vim Normal file
View file

@ -0,0 +1,49 @@
let s:suite = themis#suite('toml')
let s:assert = themis#helper('assert')
let g:path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
function! s:suite.before_each() abort
let g:temp = tempname()
call neobundle#begin(g:path)
endfunction
function! s:suite.after_each() abort
call neobundle#end()
call delete(g:temp)
endfunction
function! s:suite.no_toml() abort
call writefile([
\ 'foobar'
\ ], g:temp)
call s:assert.equals(neobundle#parser#load_toml(g:temp, {}), 1)
endfunction
function! s:suite.no_plugins() abort
call writefile([], g:temp)
call s:assert.equals(neobundle#parser#load_toml(g:temp, {}), 1)
endfunction
function! s:suite.no_repository() abort
call writefile([
\ "[[plugins]]",
\ "filetypes = 'all'",
\ "[[plugins]]",
\ "filetypes = 'all'"
\ ], g:temp)
call s:assert.equals(neobundle#parser#load_toml(g:temp, {}), 1)
endfunction
function! s:suite.normal() abort
call writefile([
\ "[[plugins]]",
\ "repository = 'Shougo/tabpagebuffer.vim'",
\ "filetypes = 'all'",
\ "[[plugins]]",
\ "repository = 'Shougo/tabpagebuffer.vim'",
\ "filetypes = 'all'"
\ ], g:temp)
call s:assert.equals(neobundle#parser#load_toml(g:temp, {}), 0)
endfunction

182
.vim/bundle/neobundle.vim/test/tsort.vim Normal file
View file

@ -0,0 +1,182 @@
let s:suite = themis#suite('tsort')
let s:assert = themis#helper('assert')
let g:path = expand('~/test-bundle/'.fnamemodify(expand('<sfile>'), ':t:r'))
function! s:comp_bundle(bundle1, bundle2) abort
return a:bundle1.name > a:bundle2.name
endfunction
function! s:rotate_bundle(bundles) abort
return a:bundles[1:-1]+a:bundles[0:0]
endfunction
function! s:suite.before_each() abort
endfunction
function! s:suite.after_each() abort
endfunction
function! s:suite.no_depends() abort
" [a, b, c] => [a, b, c]
let neobundle_test_data = [{'name' : 'a'}, {'name' : 'b'}, {'name' : 'c'},]
call s:assert.equals(neobundle#config#tsort(neobundle_test_data),
\ neobundle_test_data)
endfunction
function! s:suite.normal() abort
" a -> b -> c
" b -> d
" c
" [a, b, c] => [c, b, a]
let neobundle_test_data = [
\ {'name' : 'a', 'depends' : [
\ {'name' : 'b', 'depends' : [
\ {'name' : 'c'},
\ ]},
\ ]},
\ {'name' : 'b', 'skip' : 1, 'depends' : [
\ {'name' : 'd', 'skipped' : 1, },
\ ]},
\ {'name' : 'c', 'skip' : 1},
\ ]
call s:assert.equals(neobundle#config#tsort(neobundle_test_data), [
\ neobundle_test_data[0].depends[0].depends[0],
\ neobundle_test_data[0].depends[0],
\ neobundle_test_data[0],
\ ])
" a -> c -> b
" a -> d
" b
" c
" [a, b, c] => [b, c, d, a]
let neobundle_test_data = [
\ {'name' : 'a', 'depends' : [
\ {'name' : 'c', 'depends' : [
\ {'name' : 'b'},
\ ]},
\ {'name' : 'd'},
\ ]},
\ {'name' : 'b', 'skip' : 1},
\ {'name' : 'c', 'skip' : 1},
\ ]
call s:assert.equals(neobundle#config#tsort(neobundle_test_data),
\ [
\ neobundle_test_data[0].depends[0].depends[0],
\ neobundle_test_data[0].depends[0],
\ neobundle_test_data[0].depends[1],
\ neobundle_test_data[0],
\ ])
endfunction
function! s:suite.tsort_circular_reference() abort
" a -> b -> c -> a
" b
" c
" [a, b, c] => [c, b, a]
let neobundle_test_data = [
\ {'name' : 'a', 'depends' : [
\ {'name' : 'b', 'depends' : [
\ {'name' : 'c', 'depends' : [
\ {'name' : 'a', 'skip' : 1},
\ ]},
\ ]},
\ ]},
\ {'name' : 'b', 'skip' : 1},
\ {'name' : 'c', 'skip' : 1},
\ ]
call s:assert.equals(neobundle#config#tsort(neobundle_test_data),
\ [
\ neobundle_test_data[0].depends[0].depends[0],
\ neobundle_test_data[0].depends[0],
\ neobundle_test_data[0],
\ ])
endfunction
function! s:suite.bundled_no_depends() abort
call neobundle#begin(g:path)
NeoBundleLazy 'a/a'
NeoBundleLazy 'b/b'
NeoBundleLazy 'c/c'
call neobundle#end()
let neobundle_test_data = sort(filter(neobundle#config#get_neobundles(),
\ "v:val.name =~# '^[abc]$'"), "s:comp_bundle")
" [a, b, c] => [a, b, c]
call s:assert.equals(s:map(neobundle#config#tsort(neobundle_test_data)),
\ s:map(neobundle_test_data))
" [c, b, a] => [c, b, a]
call reverse(neobundle_test_data)
call s:assert.equals(s:map(neobundle#config#tsort(neobundle_test_data)),
\ s:map(neobundle_test_data))
endfunction
function! s:suite.bundled_normal() abort
call neobundle#begin(g:path)
NeoBundleLazy 'a/a'
NeoBundleLazy 'b/b', {'depends' : 'a/a'}
NeoBundleLazy 'c/c', {'depends' : 'b/b'}
call neobundle#end()
let neobundle_test_data = sort(filter(neobundle#config#get_neobundles(),
\ "v:val.name =~# '^[abc]$'"), "s:comp_bundle")
" [a, b, c] => [a, b, c]
call s:assert.equals(s:map(neobundle#config#tsort(neobundle_test_data)),
\ s:map(neobundle_test_data))
" [c, b, a] => [a, b, c]
call s:assert.equals(s:map(neobundle#config#tsort(
\ reverse(copy(neobundle_test_data)))), s:map(neobundle_test_data))
endfunction
function! s:suite.bundled_normal2() abort
call neobundle#begin(g:path)
NeoBundleLazy 'a/a', {'depends' : ['c/c', 'b/b']}
NeoBundleLazy 'b/b'
NeoBundleLazy 'c/c', {'depends' : 'b/b'}
call neobundle#end()
let neobundle_test_data = sort(filter(neobundle#config#get_neobundles(),
\ "v:val.name =~# '^[abc]$'"), "s:comp_bundle")
let neobundle_test_rotated = s:map(s:rotate_bundle(neobundle_test_data))
" [a, b, c] => [b, c, a]
call s:assert.equals(s:map(neobundle#config#tsort(
\ neobundle_test_data)),
\ neobundle_test_rotated)
" [c, b, a] => [b, c, a]
call s:assert.equals(s:map(neobundle#config#tsort(
\ reverse(copy(neobundle_test_data)))),
\ neobundle_test_rotated)
endfunction
function! s:suite.bundled_circular_reference() abort
call neobundle#begin(g:path)
NeoBundleLazy 'a/a', {'depends' : 'b/b'}
NeoBundleLazy 'b/b', {'depends' : 'c/c'}
NeoBundleLazy 'c/c', {'depends' : 'a/a'}
call neobundle#end()
let neobundle_test_data = sort(filter(neobundle#config#get_neobundles(),
\ "v:val.name =~# '^[abc]$'"), "s:comp_bundle")
" [a, b, c] => [c, b, a]
call s:assert.equals(s:map(neobundle#config#tsort(neobundle_test_data)),
\ s:map(reverse(copy(neobundle_test_data))))
" [c, b, a] => [b, a, c]
call reverse(neobundle_test_data)
let neobundle_test_rotated = s:rotate_bundle(neobundle_test_data)
call s:assert.equals(s:map(neobundle#config#tsort(neobundle_test_data)),
\ s:map(neobundle_test_rotated))
endfunction
function! s:map(list) abort
return map(copy(a:list), 'v:val.name')
endfunction