From 5a1c95140fb1f2c9479b1c86a6ebc4dde937671b Mon Sep 17 00:00:00 2001 From: Barak Michener Date: Thu, 27 Oct 2016 13:40:04 -0700 Subject: [PATCH] switch to neobundle --- .vim/bundle/Vundle.vim/.gitignore | 2 - .vim/bundle/Vundle.vim/CONTRIBUTING.md | 111 -- .vim/bundle/Vundle.vim/LICENSE-MIT.txt | 7 - .vim/bundle/Vundle.vim/README.md | 158 -- .vim/bundle/Vundle.vim/autoload/vundle.vim | 83 - .vim/bundle/Vundle.vim/autoload/vundle/config.vim | 278 ---- .../Vundle.vim/autoload/vundle/installer.vim | 534 ------ .vim/bundle/Vundle.vim/autoload/vundle/scripts.vim | 257 --- .vim/bundle/Vundle.vim/changelog.md | 22 - .vim/bundle/Vundle.vim/doc/vundle.txt | 397 ----- .vim/bundle/Vundle.vim/test/files/test.erl | 20 - .vim/bundle/Vundle.vim/test/minirc.vim | 8 - .vim/bundle/Vundle.vim/test/vimrc | 81 - .vim/bundle/neobundle.vim/.gitignore | 1 + .vim/bundle/neobundle.vim/.travis.yml | 13 + .vim/bundle/neobundle.vim/LICENSE-MIT.txt | 7 + .vim/bundle/neobundle.vim/Makefile | 15 + .vim/bundle/neobundle.vim/README.md | 148 ++ .vim/bundle/neobundle.vim/autoload/neobundle.vim | 448 +++++ .../neobundle.vim/autoload/neobundle/TOML.vim | 332 ++++ .../neobundle.vim/autoload/neobundle/autoload.vim | 275 +++ .../neobundle.vim/autoload/neobundle/cache.vim | 79 + .../neobundle.vim/autoload/neobundle/commands.vim | 760 +++++++++ .../neobundle.vim/autoload/neobundle/config.vim | 761 +++++++++ .../neobundle.vim/autoload/neobundle/init.vim | 300 ++++ .../neobundle.vim/autoload/neobundle/installer.vim | 892 ++++++++++ .../neobundle.vim/autoload/neobundle/metadata.vim | 84 + .../neobundle.vim/autoload/neobundle/parser.vim | 314 ++++ .../autoload/neobundle/sources/github.vim | 119 ++ .../autoload/neobundle/sources/metadata.vim | 104 ++ .../autoload/neobundle/sources/vim_scripts_org.vim | 160 ++ .../neobundle.vim/autoload/neobundle/types/git.vim | 312 ++++ .../neobundle.vim/autoload/neobundle/types/hg.vim | 119 ++ .../autoload/neobundle/types/none.vim | 75 + .../neobundle.vim/autoload/neobundle/types/raw.vim | 116 ++ .../neobundle.vim/autoload/neobundle/types/svn.vim | 93 ++ .../neobundle.vim/autoload/neobundle/types/vba.vim | 146 ++ .../neobundle.vim/autoload/neobundle/util.vim | 510 ++++++ .../autoload/unite/kinds/neobundle.vim | 106 ++ .../autoload/unite/sources/neobundle.vim | 143 ++ .../autoload/unite/sources/neobundle_install.vim | 190 +++ .../autoload/unite/sources/neobundle_lazy.vim | 76 + .../autoload/unite/sources/neobundle_log.vim | 66 + .../autoload/unite/sources/neobundle_search.vim | 265 +++ .vim/bundle/neobundle.vim/bin/install.sh | 137 ++ .vim/bundle/neobundle.vim/bin/neoinstall | 12 + .vim/bundle/neobundle.vim/bin/neoinstall.bat | 30 + .../neobundle.vim/bin/neoinstall_novimproc.bat | 30 + .vim/bundle/neobundle.vim/doc/neobundle.txt | 1753 ++++++++++++++++++++ .vim/bundle/neobundle.vim/plugin/neobundle.vim | 60 + .vim/bundle/neobundle.vim/test/commands.vim | 117 ++ .vim/bundle/neobundle.vim/test/lock.vim | 35 + .vim/bundle/neobundle.vim/test/parse.vim | 333 ++++ .vim/bundle/neobundle.vim/test/sample.vim | 39 + .vim/bundle/neobundle.vim/test/source.vim | 95 ++ .vim/bundle/neobundle.vim/test/toml.vim | 49 + .vim/bundle/neobundle.vim/test/tsort.vim | 182 ++ 57 files changed, 9901 insertions(+), 1958 deletions(-) delete mode 100644 .vim/bundle/Vundle.vim/.gitignore delete mode 100644 .vim/bundle/Vundle.vim/CONTRIBUTING.md delete mode 100644 .vim/bundle/Vundle.vim/LICENSE-MIT.txt delete mode 100644 .vim/bundle/Vundle.vim/README.md delete mode 100644 .vim/bundle/Vundle.vim/autoload/vundle.vim delete mode 100644 .vim/bundle/Vundle.vim/autoload/vundle/config.vim delete mode 100644 .vim/bundle/Vundle.vim/autoload/vundle/installer.vim delete mode 100644 .vim/bundle/Vundle.vim/autoload/vundle/scripts.vim delete mode 100644 .vim/bundle/Vundle.vim/changelog.md delete mode 100644 .vim/bundle/Vundle.vim/doc/vundle.txt delete mode 100644 .vim/bundle/Vundle.vim/test/files/test.erl delete mode 100644 .vim/bundle/Vundle.vim/test/minirc.vim delete mode 100644 .vim/bundle/Vundle.vim/test/vimrc create mode 100644 .vim/bundle/neobundle.vim/.gitignore create mode 100644 .vim/bundle/neobundle.vim/.travis.yml create mode 100644 .vim/bundle/neobundle.vim/LICENSE-MIT.txt create mode 100644 .vim/bundle/neobundle.vim/Makefile create mode 100644 .vim/bundle/neobundle.vim/README.md create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/TOML.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/autoload.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/cache.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/commands.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/config.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/init.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/installer.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/metadata.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/parser.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/sources/github.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/sources/metadata.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/sources/vim_scripts_org.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/git.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/hg.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/none.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/raw.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/svn.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/types/vba.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/neobundle/util.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/kinds/neobundle.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/sources/neobundle.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_install.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_lazy.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_log.vim create mode 100644 .vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_search.vim create mode 100755 .vim/bundle/neobundle.vim/bin/install.sh create mode 100755 .vim/bundle/neobundle.vim/bin/neoinstall create mode 100644 .vim/bundle/neobundle.vim/bin/neoinstall.bat create mode 100644 .vim/bundle/neobundle.vim/bin/neoinstall_novimproc.bat create mode 100644 .vim/bundle/neobundle.vim/doc/neobundle.txt create mode 100644 .vim/bundle/neobundle.vim/plugin/neobundle.vim create mode 100644 .vim/bundle/neobundle.vim/test/commands.vim create mode 100644 .vim/bundle/neobundle.vim/test/lock.vim create mode 100644 .vim/bundle/neobundle.vim/test/parse.vim create mode 100644 .vim/bundle/neobundle.vim/test/sample.vim create mode 100644 .vim/bundle/neobundle.vim/test/source.vim create mode 100644 .vim/bundle/neobundle.vim/test/toml.vim create mode 100644 .vim/bundle/neobundle.vim/test/tsort.vim diff --git a/.vim/bundle/Vundle.vim/.gitignore b/.vim/bundle/Vundle.vim/.gitignore deleted file mode 100644 index f276604..0000000 --- a/.vim/bundle/Vundle.vim/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -doc/tags -.netrwhist diff --git a/.vim/bundle/Vundle.vim/CONTRIBUTING.md b/.vim/bundle/Vundle.vim/CONTRIBUTING.md deleted file mode 100644 index 2162ffc..0000000 --- a/.vim/bundle/Vundle.vim/CONTRIBUTING.md +++ /dev/null @@ -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 -``` diff --git a/.vim/bundle/Vundle.vim/LICENSE-MIT.txt b/.vim/bundle/Vundle.vim/LICENSE-MIT.txt deleted file mode 100644 index 003904d..0000000 --- a/.vim/bundle/Vundle.vim/LICENSE-MIT.txt +++ /dev/null @@ -1,7 +0,0 @@ -Copyright (C) 2010 http://github.com/gmarik - -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. diff --git a/.vim/bundle/Vundle.vim/README.md b/.vim/bundle/Vundle.vim/README.md deleted file mode 100644 index b8a7fdb..0000000 --- a/.vim/bundle/Vundle.vim/README.md +++ /dev/null @@ -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 diff --git a/.vim/bundle/Vundle.vim/autoload/vundle.vim b/.vim/bundle/Vundle.vim/autoload/vundle.vim deleted file mode 100644 index 2939048..0000000 --- a/.vim/bundle/Vundle.vim/autoload/vundle.vim +++ /dev/null @@ -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() - -com! -nargs=? -bang -complete=custom,vundle#scripts#complete PluginInstall -\ call vundle#installer#new('!' == '', ) - -com! -nargs=? -bang -complete=custom,vundle#scripts#complete PluginSearch -\ call vundle#scripts#all('!' == '', ) - -com! -nargs=0 -bang PluginList -\ call vundle#installer#list('!' == '') - -com! -nargs=? -bang PluginClean -\ call vundle#installer#clean('!' == '') - -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 -com! -nargs=? -bang -complete=custom,vundle#scripts#complete VundleSearch PluginSearch -com! -nargs=? -bang VundleClean PluginClean -com! -nargs=0 VundleDocs PluginDocs -com! VundleUpdate PluginInstall! - -" Deprecated Commands -com! -nargs=+ Bundle call vundle#config#bundle() -com! -nargs=? -bang -complete=custom,vundle#scripts#complete BundleInstall PluginInstall -com! -nargs=? -bang -complete=custom,vundle#scripts#complete BundleSearch PluginSearch -com! -nargs=0 -bang BundleList PluginList -com! -nargs=? -bang BundleClean PluginClean -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: diff --git a/.vim/bundle/Vundle.vim/autoload/vundle/config.vim b/.vim/bundle/Vundle.vim/autoload/vundle/config.vim deleted file mode 100644 index 5ecb30b..0000000 --- a/.vim/bundle/Vundle.vim/autoload/vundle/config.vim +++ /dev/null @@ -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: diff --git a/.vim/bundle/Vundle.vim/autoload/vundle/installer.vim b/.vim/bundle/Vundle.vim/autoload/vundle/installer.vim deleted file mode 100644 index 614b64b..0000000 --- a/.vim/bundle/Vundle.vim/autoload/vundle/installer.vim +++ /dev/null @@ -1,534 +0,0 @@ -" --------------------------------------------------------------------------- -" Try to clone all new bundles given (or all bundles in g:bundles by default) -" to g:bundle_dir. If a:bang is 1 it will also update all plugins (git pull). -" -" bang -- 1 or 0 -" ... -- any number of bundle specifications (separate arguments) -" --------------------------------------------------------------------------- -func! vundle#installer#new(bang, ...) abort - let bundles = (a:1 == '') ? - \ g:bundles : - \ map(copy(a:000), 'vundle#config#bundle(v:val, {})') - - let names = vundle#scripts#bundle_names(map(copy(bundles), 'v:val.name_spec')) - call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:bundle_dir, 1)], names + ['Helptags']) - - " This calls 'add' as a normal mode command. This is a buffer local mapping - " defined in vundle#scripts#view(). The mapping will call a buffer local - " command InstallPlugin which in turn will call vundle#installer#run() with - " vundle#installer#install(). - call s:process(a:bang, (a:bang ? 'add!' : 'add')) - - call vundle#config#require(bundles) -endf - - -" --------------------------------------------------------------------------- -" Iterate over all lines in a Vundle window and execute the given command for -" every line. Used by the installation and cleaning functions. -" -" bang -- not used (FIXME) -" cmd -- the (normal mode) command to execute for every line as a string -" --------------------------------------------------------------------------- -func! s:process(bang, cmd) - let msg = '' - - redraw - sleep 1m - - let lines = (getline('.','$')[0:-2]) - - for line in lines - redraw - - exec ':norm '.a:cmd - - if 'error' == g:vundle_last_status - let msg = 'With errors; press l to view log' - endif - - if 'updated' == g:vundle_last_status && empty(msg) - let msg = 'Plugins updated; press u to view changelog' - endif - - " goto next one - exec ':+1' - - setl nomodified - endfor - - redraw - echo 'Done! '.msg -endf - - -" --------------------------------------------------------------------------- -" Call another function in the different Vundle windows. -" -" func_name -- the function to call -" name -- the bundle name to call func_name for (string) -" ... -- the argument to be used when calling func_name (only the first -" optional argument will be used) -" return -- the status returned by the call to func_name -" --------------------------------------------------------------------------- -func! vundle#installer#run(func_name, name, ...) abort - let n = a:name - - echo 'Processing '.n - call s:sign('active') - - sleep 1m - - let status = call(a:func_name, a:1) - - call s:sign(status) - - redraw - - if 'new' == status - echo n.' installed' - elseif 'updated' == status - echo n.' updated' - elseif 'todate' == status - echo n.' already installed' - elseif 'deleted' == status - echo n.' deleted' - elseif 'helptags' == status - echo n.' regenerated' - elseif 'pinned' == status - echo n.' pinned' - elseif 'error' == status - echohl Error - echo 'Error processing '.n - echohl None - sleep 1 - else - throw 'whoops, unknown status:'.status - endif - - let g:vundle_last_status = status - - return status -endf - - -" --------------------------------------------------------------------------- -" Put a sign on the current line, indicating the status of the installation -" step. -" -" status -- string describing the status -" --------------------------------------------------------------------------- -func! s:sign(status) - if (!has('signs')) - return - endif - - exe ":sign place ".line('.')." line=".line('.')." name=Vu_". a:status ." buffer=" . bufnr("%") -endf - - -" --------------------------------------------------------------------------- -" Install a plugin, then add it to the runtimepath and source it. -" -" bang -- 1 or 0, passed directly to vundle#installer#install() -" name -- the name of a bundle (string) -" return -- the return value from vundle#installer#install() -" --------------------------------------------------------------------------- -func! vundle#installer#install_and_require(bang, name) abort - let result = vundle#installer#install(a:bang, a:name) - let b = vundle#config#bundle(a:name, {}) - call vundle#installer#helptags([b]) - call vundle#config#require([b]) - return result -endf - - -" --------------------------------------------------------------------------- -" Install or update a bundle given by its name. -" -" bang -- 1 or 0, passed directly to s:sync() -" name -- the name of a bundle (string) -" return -- the return value from s:sync() -" --------------------------------------------------------------------------- -func! vundle#installer#install(bang, name) abort - if !isdirectory(g:bundle_dir) | call mkdir(g:bundle_dir, 'p') | endif - - let n = substitute(a:name,"['".'"]\+','','g') - let matched = filter(copy(g:bundles), 'v:val.name_spec == n') - - if len(matched) > 0 - let b = matched[0] - else - let b = vundle#config#init_bundle(a:name, {}) - endif - - return s:sync(a:bang, b) -endf - - -" --------------------------------------------------------------------------- -" Call :helptags for all bundles in g:bundles. -" -" return -- 'error' if an error occurred, else return 'helptags' -" --------------------------------------------------------------------------- -func! vundle#installer#docs() abort - let error_count = vundle#installer#helptags(g:bundles) - if error_count > 0 - return 'error' - endif - return 'helptags' -endf - - -" --------------------------------------------------------------------------- -" Call :helptags for a list of bundles. -" -" bundles -- a list of bundle dictionaries for which :helptags should be -" called. -" return -- the number of directories where :helptags failed -" --------------------------------------------------------------------------- -func! vundle#installer#helptags(bundles) abort - let bundle_dirs = map(copy(a:bundles),'v:val.rtpath') - let help_dirs = filter(bundle_dirs, 's:has_doc(v:val)') - - call s:log('') - call s:log('Helptags:') - - let statuses = map(copy(help_dirs), 's:helptags(v:val)') - let errors = filter(statuses, 'v:val == 0') - - call s:log('Helptags: '.len(help_dirs).' plugins processed') - - return len(errors) -endf - - -" --------------------------------------------------------------------------- -" List all installed plugins. -" Corresponding documentation: vundle-plugins-list -" -" bang -- not used -" --------------------------------------------------------------------------- -func! vundle#installer#list(bang) abort - let bundles = vundle#scripts#bundle_names(map(copy(g:bundles), 'v:val.name_spec')) - call vundle#scripts#view('list', ['" My Plugins'], bundles) - redraw - echo len(g:bundles).' plugins configured' -endf - - -" --------------------------------------------------------------------------- -" List and remove all directories in the bundle directory which are not -" activated (added to the bundle list). -" -" bang -- 0 if the user should be asked to confirm every deletion, 1 if they -" should be removed unconditionally -" --------------------------------------------------------------------------- -func! vundle#installer#clean(bang) abort - let bundle_dirs = map(copy(g:bundles), 'v:val.path()') - let all_dirs = (v:version > 702 || (v:version == 702 && has("patch51"))) - \ ? split(globpath(g:bundle_dir, '*', 1), "\n") - \ : split(globpath(g:bundle_dir, '*'), "\n") - let x_dirs = filter(all_dirs, '0 > index(bundle_dirs, v:val)') - - if empty(x_dirs) - let headers = ['" All clean!'] - let names = [] - else - let headers = ['" Removing Plugins:'] - let names = vundle#scripts#bundle_names(map(copy(x_dirs), 'fnamemodify(v:val, ":t")')) - end - - call vundle#scripts#view('clean', headers, names) - redraw - - if (a:bang || empty(names)) - call s:process(a:bang, 'D') - else - call inputsave() - let response = input('Continue? [Y/n]: ') - call inputrestore() - if (response =~? 'y' || response == '') - call s:process(a:bang, 'D') - endif - endif -endf - - -" --------------------------------------------------------------------------- -" Delete to directory for a plugin. -" -" bang -- not used -" dir_name -- the bundle directory to be deleted (as a string) -" return -- 'error' if an error occurred, 'deleted' if the plugin folder was -" successfully deleted -" --------------------------------------------------------------------------- -func! vundle#installer#delete(bang, dir_name) abort - - let cmd = ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh'))) ? - \ 'rmdir /S /Q' : - \ 'rm -rf' - - let bundle = vundle#config#init_bundle(a:dir_name, {}) - let cmd .= ' '.vundle#installer#shellesc(bundle.path()) - - let out = s:system(cmd) - - call s:log('') - call s:log('Plugin '.a:dir_name) - call s:log(cmd, '$ ') - call s:log(out, '> ') - - if 0 != v:shell_error - return 'error' - else - return 'deleted' - endif -endf - - -" --------------------------------------------------------------------------- -" Check if a bundled plugin has any documentation. -" -" rtp -- a path (string) where the plugin is installed -" return -- 1 if some documentation was found, 0 otherwise -" --------------------------------------------------------------------------- -func! s:has_doc(rtp) abort - return isdirectory(a:rtp.'/doc') - \ && (!filereadable(a:rtp.'/doc/tags') || filewritable(a:rtp.'/doc/tags')) - \ && (v:version > 702 || (v:version == 702 && has("patch51"))) - \ ? !(empty(glob(a:rtp.'/doc/*.txt', 1)) && empty(glob(a:rtp.'/doc/*.??x', 1))) - \ : !(empty(glob(a:rtp.'/doc/*.txt')) && empty(glob(a:rtp.'/doc/*.??x'))) -endf - - -" --------------------------------------------------------------------------- -" Update the helptags for a plugin. -" -" rtp -- the path to the plugin's root directory (string) -" return -- 1 if :helptags succeeded, 0 otherwise -" --------------------------------------------------------------------------- -func! s:helptags(rtp) abort - " it is important to keep trailing slash here - let doc_path = resolve(a:rtp . '/doc/') - call s:log(':helptags '.doc_path) - try - execute 'helptags ' . doc_path - catch - call s:log("> Error running :helptags ".doc_path) - return 0 - endtry - return 1 -endf - - -" --------------------------------------------------------------------------- -" Get the URL for the remote called 'origin' on the repository that -" corresponds to a given bundle. -" -" bundle -- a bundle object to check the repository for -" return -- the URL for the origin remote (string) -" --------------------------------------------------------------------------- -func! s:get_current_origin_url(bundle) abort - let cmd = 'cd '.vundle#installer#shellesc(a:bundle.path()).' && git config --get remote.origin.url' - let cmd = vundle#installer#shellesc_cd(cmd) - let out = s:strip(s:system(cmd)) - return out -endf - - -" --------------------------------------------------------------------------- -" Get a short sha of the HEAD of the repository for a given bundle -" -" bundle -- a bundle object -" return -- A 15 character log sha for the current HEAD -" --------------------------------------------------------------------------- -func! s:get_current_sha(bundle) - let cmd = 'cd '.vundle#installer#shellesc(a:bundle.path()).' && git rev-parse HEAD' - let cmd = vundle#installer#shellesc_cd(cmd) - let out = s:system(cmd)[0:15] - return out -endf - - -" --------------------------------------------------------------------------- -" Create the appropriate sync command to run according to the current state of -" the local repository (clone, pull, reset, etc). -" -" In the case of a pull (update), also return the current sha, so that we can -" later check that there has been an upgrade. -" -" bang -- 0 if only new plugins should be installed, 1 if existing plugins -" should be updated -" bundle -- a bundle object to create the sync command for -" return -- A list containing the command to run and the sha for the current -" HEAD -" --------------------------------------------------------------------------- -func! s:make_sync_command(bang, bundle) abort - let git_dir = expand(a:bundle.path().'/.git/', 1) - if isdirectory(git_dir) || filereadable(expand(a:bundle.path().'/.git', 1)) - - let current_origin_url = s:get_current_origin_url(a:bundle) - if current_origin_url != a:bundle.uri - call s:log('Plugin URI change detected for Plugin ' . a:bundle.name) - call s:log('> Plugin ' . a:bundle.name . ' old URI: ' . current_origin_url) - call s:log('> Plugin ' . a:bundle.name . ' new URI: ' . a:bundle.uri) - " Directory names match but the origin remotes are not the same - let cmd_parts = [ - \ 'cd '.vundle#installer#shellesc(a:bundle.path()) , - \ 'git remote set-url origin ' . vundle#installer#shellesc(a:bundle.uri), - \ 'git fetch', - \ 'git reset --hard origin/HEAD', - \ 'git submodule update --init --recursive', - \ ] - let cmd = join(cmd_parts, ' && ') - let cmd = vundle#installer#shellesc_cd(cmd) - let initial_sha = '' - return [cmd, initial_sha] - endif - - if !(a:bang) - " The repo exists, and no !, so leave as it is. - return ['', ''] - endif - - let cmd_parts = [ - \ 'cd '.vundle#installer#shellesc(a:bundle.path()), - \ 'git pull', - \ 'git submodule update --init --recursive', - \ ] - let cmd = join(cmd_parts, ' && ') - let cmd = vundle#installer#shellesc_cd(cmd) - - let initial_sha = s:get_current_sha(a:bundle) - else - let cmd = 'git clone --recursive '.vundle#installer#shellesc(a:bundle.uri).' '.vundle#installer#shellesc(a:bundle.path()) - let initial_sha = '' - endif - return [cmd, initial_sha] -endf - - -" --------------------------------------------------------------------------- -" Install or update a given bundle object with git. -" -" bang -- 0 if only new plugins should be installed, 1 if existing plugins -" should be updated -" bundle -- a bundle object (dictionary) -" return -- a string indicating the status of the bundle installation: -" - todate : Nothing was updated or the repository was up to date -" - new : The plugin was newly installed -" - updated : Some changes where pulled via git -" - error : An error occurred in the shell command -" - pinned : The bundle is marked as pinned -" --------------------------------------------------------------------------- -func! s:sync(bang, bundle) abort - " Do not sync if this bundle is pinned - if a:bundle.is_pinned() - return 'pinned' - endif - - let [ cmd, initial_sha ] = s:make_sync_command(a:bang, a:bundle) - if empty(cmd) - return 'todate' - endif - - let out = s:system(cmd) - call s:log('') - call s:log('Plugin '.a:bundle.name_spec) - call s:log(cmd, '$ ') - call s:log(out, '> ') - - if 0 != v:shell_error - return 'error' - end - - if empty(initial_sha) - return 'new' - endif - - let updated_sha = s:get_current_sha(a:bundle) - - if initial_sha == updated_sha - return 'todate' - endif - - call add(g:updated_bundles, [initial_sha, updated_sha, a:bundle]) - return 'updated' -endf - - -" --------------------------------------------------------------------------- -" Escape special characters in a string to be able to use it as a shell -" command with system(). -" -" cmd -- the string holding the shell command -" return -- a string with the relevant characters escaped -" --------------------------------------------------------------------------- -func! vundle#installer#shellesc(cmd) abort - if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh'))) - return '"' . substitute(a:cmd, '"', '\\"', 'g') . '"' - endif - return shellescape(a:cmd) -endf - - -" --------------------------------------------------------------------------- -" Fix a cd shell command to be used on Windows. -" -" cmd -- the command to be fixed (string) -" return -- the fixed command (string) -" --------------------------------------------------------------------------- -func! vundle#installer#shellesc_cd(cmd) abort - if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh'))) - let cmd = substitute(a:cmd, '^cd ','cd /d ','') " add /d switch to change drives - return cmd - else - return a:cmd - endif -endf - - -" --------------------------------------------------------------------------- -" Make a system call. This can be used to change the way system calls -" are made during developing, without searching the whole code base for -" actual system() calls. -" -" cmd -- the command passed to system() (string) -" return -- the return value from system() -" --------------------------------------------------------------------------- -func! s:system(cmd) abort - return system(a:cmd) -endf - - -" --------------------------------------------------------------------------- -" Add a log message to Vundle's internal logging variable. -" -" str -- the log message (string) -" prefix -- optional prefix for multi-line entries (string) -" return -- a:str -" --------------------------------------------------------------------------- -func! s:log(str, ...) abort - let prefix = a:0 > 0 ? a:1 : '' - let fmt = '%Y-%m-%d %H:%M:%S' - let lines = split(a:str, '\n', 1) - let time = strftime(fmt) - for line in lines - call add(g:vundle_log, '['. time .'] '. prefix . line) - endfor - return a:str -endf - - -" --------------------------------------------------------------------------- -" Remove leading and trailing whitespace from a string -" -" str -- The string to rid of trailing and leading spaces -" return -- A string stripped of side spaces -" --------------------------------------------------------------------------- -func! s:strip(str) - return substitute(a:str, '\%^\_s*\(.\{-}\)\_s*\%$', '\1', '') -endf - -" vim: set expandtab sts=2 ts=2 sw=2 tw=78 norl: diff --git a/.vim/bundle/Vundle.vim/autoload/vundle/scripts.vim b/.vim/bundle/Vundle.vim/autoload/vundle/scripts.vim deleted file mode 100644 index d7409a1..0000000 --- a/.vim/bundle/Vundle.vim/autoload/vundle/scripts.vim +++ /dev/null @@ -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(,',')[0], ['!' == '', ]) - - com! -buffer -bang -nargs=? InstallAndRequirePlugin - \ call vundle#installer#run('vundle#installer#install_and_require', split(,',')[0], ['!' == '', ]) - - com! -buffer -bang -nargs=? InstallPlugin - \ call vundle#installer#run('vundle#installer#install', split(,',')[0], ['!' == '', ]) - - 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 q :silent bd! - nnoremap D :exec 'Delete'.getline('.') - - nnoremap add :exec 'Install'.getline('.') - nnoremap add! :exec 'Install'.substitute(getline('.'), '^Plugin ', 'Plugin! ', '') - - nnoremap i :exec 'InstallAndRequire'.getline('.') - nnoremap I :exec 'InstallAndRequire'.substitute(getline('.'), '^Plugin ', 'Plugin! ', '') - - nnoremap l :VundleLog - nnoremap u :VundleChangelog - nnoremap h :h vundle - nnoremap ? :norm h - - nnoremap c :PluginClean - nnoremap C :PluginClean! - - nnoremap s :PluginSearch - nnoremap R :call vundle#scripts#reload() - - " 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: diff --git a/.vim/bundle/Vundle.vim/changelog.md b/.vim/bundle/Vundle.vim/changelog.md deleted file mode 100644 index b620840..0000000 --- a/.vim/bundle/Vundle.vim/changelog.md +++ /dev/null @@ -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 diff --git a/.vim/bundle/Vundle.vim/doc/vundle.txt b/.vim/bundle/Vundle.vim/doc/vundle.txt deleted file mode 100644 index 198584b..0000000 --- a/.vim/bundle/Vundle.vim/doc/vundle.txt +++ /dev/null @@ -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: diff --git a/.vim/bundle/Vundle.vim/test/files/test.erl b/.vim/bundle/Vundle.vim/test/files/test.erl deleted file mode 100644 index 1672953..0000000 --- a/.vim/bundle/Vundle.vim/test/files/test.erl +++ /dev/null @@ -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] - } - ] - }}. diff --git a/.vim/bundle/Vundle.vim/test/minirc.vim b/.vim/bundle/Vundle.vim/test/minirc.vim deleted file mode 100644 index 3c24395..0000000 --- a/.vim/bundle/Vundle.vim/test/minirc.vim +++ /dev/null @@ -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 - diff --git a/.vim/bundle/Vundle.vim/test/vimrc b/.vim/bundle/Vundle.vim/test/vimrc deleted file mode 100644 index d8455a7..0000000 --- a/.vim/bundle/Vundle.vim/test/vimrc +++ /dev/null @@ -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: diff --git a/.vim/bundle/neobundle.vim/.gitignore b/.vim/bundle/neobundle.vim/.gitignore new file mode 100644 index 0000000..926ccaa --- /dev/null +++ b/.vim/bundle/neobundle.vim/.gitignore @@ -0,0 +1 @@ +doc/tags diff --git a/.vim/bundle/neobundle.vim/.travis.yml b/.vim/bundle/neobundle.vim/.travis.yml new file mode 100644 index 0000000..8a04a43 --- /dev/null +++ b/.vim/bundle/neobundle.vim/.travis.yml @@ -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 diff --git a/.vim/bundle/neobundle.vim/LICENSE-MIT.txt b/.vim/bundle/neobundle.vim/LICENSE-MIT.txt new file mode 100644 index 0000000..003904d --- /dev/null +++ b/.vim/bundle/neobundle.vim/LICENSE-MIT.txt @@ -0,0 +1,7 @@ +Copyright (C) 2010 http://github.com/gmarik + +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. diff --git a/.vim/bundle/neobundle.vim/Makefile b/.vim/bundle/neobundle.vim/Makefile new file mode 100644 index 0000000..4987cf5 --- /dev/null +++ b/.vim/bundle/neobundle.vim/Makefile @@ -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 diff --git a/.vim/bundle/neobundle.vim/README.md b/.vim/bundle/neobundle.vim/README.md new file mode 100644 index 0000000..ff9f63c --- /dev/null +++ b/.vim/bundle/neobundle.vim/README.md @@ -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 ''`. 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}} +``` diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle.vim b/.vim/bundle/neobundle.vim/autoload/neobundle.vim new file mode 100644 index 0000000..337b3c4 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle.vim @@ -0,0 +1,448 @@ +"============================================================================= +" FILE: neobundle.vim +" AUTHOR: Shougo Matsushita +" 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(''), ':p:h:h')) + +command! -nargs=+ + \ NeoBundle + \ call neobundle#parser#bundle( + \ substitute(, '\s"[^"]\+$', '', '')) + +command! -bar + \ NeoBundleCheck + \ call neobundle#commands#check() + +command! -nargs=? -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleCheckUpdate + \ call neobundle#commands#check_update() + +command! -nargs=+ + \ NeoBundleLazy + \ call neobundle#parser#lazy( + \ substitute(, '\s"[^"]\+$', '', '')) + +command! -nargs=+ + \ NeoBundleFetch + \ call neobundle#parser#fetch( + \ substitute(, '\s"[^"]\+$', '', '')) + +command! -nargs=1 -complete=dir -bar + \ NeoBundleLocal + \ call neobundle#local(, {}) + +command! -nargs=+ -bar + \ NeoBundleDirectInstall + \ call neobundle#parser#direct( + \ substitute(, '\s"[^"]\+$', '', '')) + +command! -nargs=* -bar + \ -complete=customlist,neobundle#commands#complete_lazy_bundles + \ NeoBundleSource + \ call neobundle#commands#source([]) + +command! -nargs=+ -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleDisable + \ call neobundle#config#disable() + +command! -nargs=? -bang -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleInstall + \ call neobundle#commands#install( + \ '!' == '', ) +command! -nargs=? -bang -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleUpdate + \ call neobundle#commands#install( + \ ('!' == '' ? 2 : 1), ) + +command! -nargs=+ -bang -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleReinstall + \ call neobundle#commands#reinstall() + +command! -nargs=? -bar + \ -complete=customlist,neobundle#commands#complete_bundles + \ NeoBundleGC + \ call neobundle#commands#gc() + +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() + +command! -nargs=+ -bar + \ NeoBundleLock + \ call neobundle#commands#lock() + +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(''), ':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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/TOML.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/TOML.vim new file mode 100644 index 0000000..18c1eb0 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/TOML.vim @@ -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: diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/autoload.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/autoload.vim new file mode 100644 index 0000000..fc0e7f0 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/autoload.vim @@ -0,0 +1,275 @@ +"============================================================================= +" FILE: autoload.vim +" AUTHOR: Shougo Matsushita +" 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(''), ".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("\", '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', + \ get(g:, 'mapleader', '\'), 'g') + let mapping = substitute(mapping, '\c', + \ 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('') + 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('')) + + 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\", 'n') +endfunction"}}} + +function! s:get_input() abort "{{{ + let input = '' + let termstr = "" + + 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 + diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/cache.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/cache.vim new file mode 100644 index 0000000..d04ae6f --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/cache.vim @@ -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: diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/commands.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/commands.vim new file mode 100644 index 0000000..15dede6 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/commands.vim @@ -0,0 +1,760 @@ +"============================================================================= +" FILE: commands.vim +" AUTHOR: Shougo Matsushita +" 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. +" }}} +" Version: 3.0, for Vim 7.2 +"============================================================================= + +let s:save_cpo = &cpo +set cpo&vim + +call neobundle#util#set_default( + \ 'g:neobundle#rm_command', + \ (neobundle#util#is_windows() ? 'rmdir /S /Q' : 'rm -rf'), + \ 'g:neobundle_rm_command') + +let s:vimrcs = [] + +function! neobundle#commands#install(bang, bundle_names) abort "{{{ + if neobundle#util#is_sudo() + call neobundle#util#print_error( + \ '"sudo vim" is detected. This feature is disabled.') + return + endif + + let bundle_names = split(a:bundle_names) + + let bundles = !a:bang ? + \ neobundle#get_force_not_installed_bundles(bundle_names) : + \ empty(bundle_names) ? + \ neobundle#config#get_enabled_bundles() : + \ neobundle#config#fuzzy_search(bundle_names) + + let reinstall_bundles = + \ neobundle#installer#get_reinstall_bundles(bundles) + if !empty(reinstall_bundles) + call neobundle#installer#reinstall(reinstall_bundles) + endif + + if empty(bundles) + call neobundle#installer#error( + \ 'Target bundles not found.') + call neobundle#installer#error( + \ 'You may have used the wrong bundle name,'. + \ ' or all of the bundles are already installed.') + return + endif + + call sort(bundles, 's:cmp_vimproc') + + call neobundle#installer#_load_install_info(bundles) + + call neobundle#installer#clear_log() + + call neobundle#installer#echomsg( + \ 'Update started: ' . + \ strftime('(%Y/%m/%d %H:%M:%S)')) + + let [installed, errored] = s:install(a:bang, bundles) + if !has('vim_starting') + redraw! + endif + + call neobundle#installer#update(installed) + + call neobundle#installer#echomsg( + \ neobundle#installer#get_updated_bundles_message(installed)) + + call neobundle#installer#echomsg( + \ neobundle#installer#get_errored_bundles_message(errored)) + + call neobundle#installer#echomsg( + \ 'Update done: ' . strftime('(%Y/%m/%d %H:%M:%S)')) +endfunction"}}} + +function! neobundle#commands#helptags(bundles) abort "{{{ + if neobundle#util#is_sudo() + call neobundle#util#print_error( + \ '"sudo vim" is detected. This feature is disabled.') + return + endif + + let help_dirs = filter(copy(a:bundles), 's:has_doc(v:val.rtp)') + + if !empty(help_dirs) + try + call s:update_tags() + if !has('vim_starting') + call neobundle#installer#echomsg( + \ 'Helptags: done. ' + \ .len(help_dirs).' bundles processed') + endif + catch + call neobundle#installer#error('Error generating helptags:') + call neobundle#installer#error(v:exception) + endtry + endif + + return help_dirs +endfunction"}}} + +function! neobundle#commands#check() abort "{{{ + if neobundle#installer#get_tags_info() !=# + \ sort(map(neobundle#config#get_neobundles(), 'v:val.name')) + " Recache automatically. + NeoBundleDocs + endif + + let reinstall_bundles = neobundle#installer#get_reinstall_bundles( + \ neobundle#config#get_neobundles()) + if !empty(reinstall_bundles) + call neobundle#installer#reinstall(reinstall_bundles) + endif + + if !neobundle#exists_not_installed_bundles() + return + endif + + " Defer call during Vim startup. + " This is required for 'gui_running' and fixes issues otherwise. + if has('vim_starting') + autocmd neobundle VimEnter * NeoBundleCheck + else + echomsg 'Not installed bundles: ' + \ string(neobundle#get_not_installed_bundle_names()) + if confirm('Install bundles now?', "yes\nNo", 2) == 1 + call neobundle#commands#install(0, + \ join(neobundle#get_not_installed_bundle_names())) + endif + echo '' + endif +endfunction"}}} + +function! neobundle#commands#check_update(bundle_names) abort "{{{ + let bundle_names = split(a:bundle_names) + + " Set context. + let context = {} + let context.source__updated_bundles = [] + let context.source__processes = [] + let context.source__number = 0 + let context.source__bundles = empty(bundle_names) ? + \ neobundle#config#get_neobundles() : + \ neobundle#config#fuzzy_search(bundle_names) + + let context.source__max_bundles = + \ len(context.source__bundles) + let statusline_save = &l:statusline + try + while 1 + while context.source__number < context.source__max_bundles + \ && len(context.source__processes) < + \ g:neobundle#install_max_processes + + let bundle = context.source__bundles[context.source__number] + call s:check_update_init(bundle, context, 0) + call s:print_message( + \ neobundle#installer#get_progress_message(bundle, + \ context.source__number, + \ context.source__max_bundles)) + endwhile + + for process in context.source__processes + call s:check_update_process(context, process, 0) + endfor + + " Filter eof processes. + call filter(context.source__processes, '!v:val.eof') + + if empty(context.source__processes) + \ && context.source__number == context.source__max_bundles + break + endif + endwhile + finally + let &l:statusline = statusline_save + endtry + + let bundles = context.source__updated_bundles + redraw! + + if !empty(bundles) + echomsg 'Updates available bundles: ' + \ string(map(copy(bundles), 'v:val.name')) + echomsg ' ' + + for bundle in bundles + let cwd = getcwd() + try + call neobundle#util#cd(bundle.path) + + let type = neobundle#config#get_types(bundle.type) + let rev = neobundle#installer#get_revision_number(bundle) + let fetch_command = has_key(type, 'get_fetch_remote_command') ? + \ type.get_fetch_remote_command(bundle) : '' + let log_command = has_key(type, 'get_log_command') ? + \ type.get_log_command(bundle, bundle.remote_rev, rev) : '' + if log_command != '' + echomsg bundle.name + call neobundle#util#system(fetch_command) + for output in split(neobundle#util#system(log_command), '\n') + echomsg output + endfor + echomsg ' ' + endif + finally + call neobundle#util#cd(cwd) + endtry + endfor + + if confirm('Update bundles now?', "yes\nNo", 2) == 1 + call neobundle#commands#install(1, + \ join(map(copy(bundles), 'v:val.name'))) + endif + endif +endfunction"}}} + +function! neobundle#commands#clean(bang, ...) abort "{{{ + if neobundle#util#is_sudo() + call neobundle#util#print_error( + \ '"sudo vim" is detected. This feature is disabled.') + return + endif + + if a:0 == 0 + let all_dirs = filter(split(neobundle#util#substitute_path_separator( + \ globpath(neobundle#get_neobundle_dir(), '*', 1)), "\n"), + \ 'isdirectory(v:val)') + let bundle_dirs = map(copy(neobundle#config#get_enabled_bundles()), + \ "(v:val.script_type != '') ? + \ v:val.base . '/' . v:val.directory : v:val.path") + let x_dirs = filter(all_dirs, + \ "neobundle#config#is_disabled(fnamemodify(v:val, ':t')) + \ && index(bundle_dirs, v:val) < 0 && v:val !~ '/neobundle.vim$'") + else + let x_dirs = map(neobundle#config#search_simple(a:000), 'v:val.path') + if len(x_dirs) > len(a:000) + " Check bug. + call neobundle#util#print_error('Bug: x_dirs = %s but arguments is %s', + \ string(x_dirs), map(copy(a:000), 'v:val.path')) + return + endif + endif + + if empty(x_dirs) + let message = a:0 == 0 ? + \ 'All clean!' : + \ string(a:000) . ' is not found.' + call neobundle#installer#log(message) + return + end + + if !a:bang && !s:check_really_clean(x_dirs) + return + endif + + let cwd = getcwd() + try + " x_dirs may contain current directory. + call neobundle#util#cd(neobundle#get_neobundle_dir()) + + if !has('vim_starting') + redraw + endif + + for dir in x_dirs + call neobundle#util#rmdir(dir) + call neobundle#config#rmdir(dir) + endfor + + try + call s:update_tags() + catch + call neobundle#installer#error('Error generating helptags:') + call neobundle#installer#error(v:exception) + endtry + finally + call neobundle#util#cd(cwd) + endtry +endfunction"}}} + +function! neobundle#commands#reinstall(bundle_names) abort "{{{ + let bundles = neobundle#config#search_simple(split(a:bundle_names)) + + if empty(bundles) + call neobundle#installer#error( + \ 'Target bundles not found.') + call neobundle#installer#error( + \ 'You may have used the wrong bundle name.') + return + endif + + call neobundle#installer#reinstall(bundles) +endfunction"}}} + +function! neobundle#commands#gc(bundle_names) abort "{{{ + let bundle_names = split(a:bundle_names) + let number = 0 + let bundles = empty(bundle_names) ? + \ neobundle#config#get_enabled_bundles() : + \ neobundle#config#search_simple(bundle_names) + let max = len(bundles) + for bundle in bundles + + let number += 1 + + let type = neobundle#config#get_types(bundle.type) + if empty(type) || !has_key(type, 'get_gc_command') + continue + endif + + let cmd = type.get_gc_command(bundle) + + let cwd = getcwd() + try + " Cd to bundle path. + call neobundle#util#cd(bundle.path) + + redraw + call neobundle#util#redraw_echo( + \ printf('(%'.len(max).'d/%d): |%s| %s', + \ number, max, bundle.name, cmd)) + let result = neobundle#util#system(cmd) + redraw + call neobundle#util#redraw_echo(result) + let status = neobundle#util#get_last_status() + finally + call neobundle#util#cd(cwd) + endtry + + if status + call neobundle#installer#error(bundle.path) + call neobundle#installer#error(result) + endif + endfor +endfunction"}}} + +function! neobundle#commands#rollback(bundle_name) abort "{{{ + let bundle = get(neobundle#config#search_simple([a:bundle_name]), 0, {}) + if empty(bundle) || !isdirectory(bundle.path) + call neobundle#util#print_error(a:bundle_name . ' is not found.') + return + endif + + call neobundle#installer#_load_install_info([bundle]) + + if len(bundle.revisions) <= 1 + call neobundle#util#print_error('No revision information.') + return + endif + + let cnt = 1 + let selections = [] + let revisions = neobundle#util#sort_by( + \ items(bundle.revisions), 'v:val[0]') + for [date, revision] in revisions + call add(selections, cnt . strftime( + \ '. %Y/%D/%m %H:%M:%S ', date) . ' ' . revision) + let cnt += 1 + endfor + + let select = inputlist(['Select revision:'] + selections) + if select == '' + return + endif + + redraw + + let revision = revisions[select-1][1] + call neobundle#installer#log('[neobundle] ' . a:bundle_name . + \ ' rollbacked to ' . revision) + + let cwd = getcwd() + let revision_save = bundle.rev + try + let bundle.rev = revision + let type = neobundle#config#get_types(bundle.type) + if !has_key(type, 'get_revision_lock_command') + call neobundle#util#print_error( + \ a:bundle_name . ' is not supported this feature.') + return + endif + + let cmd = type.get_revision_lock_command(bundle) + + call neobundle#util#cd(bundle.path) + call neobundle#util#system(cmd) + finally + call neobundle#util#cd(cwd) + let bundle.rev = revision_save + endtry +endfunction"}}} + +function! neobundle#commands#list() abort "{{{ + call neobundle#util#redraw_echo('#: not sourced, X: not installed') + for bundle in neobundle#util#sort_by( + \ neobundle#config#get_neobundles(), 'tolower(v:val.name)') + echo (bundle.sourced ? ' ' : + \ neobundle#is_installed(bundle.name) ? '#' : 'X') + \ . ' ' . bundle.name + endfor +endfunction"}}} + +function! neobundle#commands#lock(name, rev) abort "{{{ + let bundle = neobundle#config#get(a:name) + if empty(bundle) + return + endif + + let bundle.install_rev = a:rev +endfunction"}}} + +function! neobundle#commands#remote_plugins() abort "{{{ + if !has('nvim') + return + endif + + " Load not loaded neovim remote plugins + call neobundle#config#source(map(filter( + \ neobundle#config#get_autoload_bundles(), + \ "isdirectory(v:val.rtp . '/rplugin')"), 'v:val.name')) + + UpdateRemotePlugins +endfunction"}}} + +function! neobundle#commands#source(names, ...) abort "{{{ + let is_force = get(a:000, 0, 1) + + let names = neobundle#util#convert2list(a:names) + if empty(names) + let bundles = [] + for bundle in neobundle#config#get_neobundles() + let bundles += neobundle#config#search([bundle.name]) + endfor + let names = neobundle#util#uniq(map(bundles, 'v:val.name')) + endif + + call neobundle#config#source(names, is_force) +endfunction "}}} + +function! neobundle#commands#complete_bundles(arglead, cmdline, cursorpos) abort "{{{ + return filter(map(neobundle#config#get_neobundles(), 'v:val.name'), + \ 'stridx(tolower(v:val), tolower(a:arglead)) >= 0') +endfunction"}}} + +function! neobundle#commands#complete_lazy_bundles(arglead, cmdline, cursorpos) abort "{{{ + return filter(map(filter(neobundle#config#get_neobundles(), + \ "!v:val.sourced && v:val.rtp != ''"), 'v:val.name'), + \ 'stridx(tolower(v:val), tolower(a:arglead)) == 0') +endfunction"}}} + +function! neobundle#commands#complete_deleted_bundles(arglead, cmdline, cursorpos) abort "{{{ + let bundle_dirs = map(copy(neobundle#config#get_neobundles()), 'v:val.path') + let all_dirs = split(neobundle#util#substitute_path_separator( + \ globpath(neobundle#get_neobundle_dir(), '*', 1)), "\n") + let x_dirs = filter(all_dirs, 'index(bundle_dirs, v:val) < 0') + + return filter(map(x_dirs, "fnamemodify(v:val, ':t')"), + \ 'stridx(v:val, a:arglead) == 0') +endfunction"}}} + +function! neobundle#commands#get_default_cache_file() abort "{{{ + return neobundle#get_rtp_dir() . '/cache' +endfunction"}}} + +function! neobundle#commands#get_cache_file() abort "{{{ + return get(g:, 'neobundle#cache_file', neobundle#commands#get_default_cache_file()) +endfunction"}}} + +function! neobundle#commands#save_cache() abort "{{{ + if !has('vim_starting') + " Ignore if loaded + return + endif + + let cache = neobundle#commands#get_cache_file() + + " Set function prefixes before save cache + call neobundle#autoload#_set_function_prefixes( + \ neobundle#config#get_autoload_bundles()) + + let bundles = neobundle#config#tsort( + \ deepcopy(neobundle#config#get_neobundles())) + for bundle in bundles + " Clear hooks. Because, VimL cannot save functions in JSON. + let bundle.hooks = {} + let bundle.sourced = 0 + endfor + + let current_vim = neobundle#util#redir('version') + + call writefile([neobundle#get_cache_version(), + \ v:progname, current_vim, string(s:vimrcs), + \ neobundle#util#vim2json(bundles)], cache) +endfunction"}}} +function! neobundle#commands#load_cache(vimrcs) abort "{{{ + let s:vimrcs = a:vimrcs + + let cache = neobundle#commands#get_cache_file() + if !filereadable(cache) | return 1 | endif + + for vimrc in a:vimrcs + let vimrc_ftime = getftime(vimrc) + if vimrc_ftime != -1 && getftime(cache) < vimrc_ftime | return 1 | endif + endfor + + let current_vim = neobundle#util#redir('version') + + try + let list = readfile(cache) + let ver = list[0] + let prog = get(list, 1, '') + let vim = get(list, 2, '') + let vimrcs = get(list, 3, '') + + if len(list) != 5 + \ || ver !=# neobundle#get_cache_version() + \ || v:progname !=# prog + \ || current_vim !=# vim + \ || string(a:vimrcs) !=# vimrcs + call neobundle#commands#clear_cache() + return 1 + endif + + let bundles = neobundle#util#json2vim(list[4]) + + if type(bundles) != type([]) + call neobundle#commands#clear_cache() + return 1 + endif + + for bundle in bundles + call neobundle#config#add(bundle) + endfor + catch + call neobundle#util#print_error( + \ 'Error occurred while loading cache : ' . v:exception) + call neobundle#commands#clear_cache() + return 1 + endtry +endfunction"}}} +function! neobundle#commands#clear_cache() abort "{{{ + let cache = neobundle#commands#get_cache_file() + if !filereadable(cache) + return + endif + + call delete(cache) +endfunction"}}} + +function! s:print_message(msg) abort "{{{ + if !has('vim_starting') + let &l:statusline = a:msg + redrawstatus + else + call neobundle#util#redraw_echo(a:msg) + endif +endfunction"}}} + +function! s:install(bang, bundles) abort "{{{ + " Set context. + let context = {} + let context.source__bang = a:bang + let context.source__synced_bundles = [] + let context.source__errored_bundles = [] + let context.source__processes = [] + let context.source__number = 0 + let context.source__bundles = a:bundles + let context.source__max_bundles = + \ len(context.source__bundles) + + let statusline_save = &l:statusline + try + + while 1 + while context.source__number < context.source__max_bundles + \ && len(context.source__processes) < + \ g:neobundle#install_max_processes + + let bundle = context.source__bundles[context.source__number] + call neobundle#installer#sync( + \ context.source__bundles[context.source__number], + \ context, 0) + call s:print_message( + \ neobundle#installer#get_progress_message(bundle, + \ context.source__number, + \ context.source__max_bundles)) + endwhile + + for process in context.source__processes + call neobundle#installer#check_output(context, process, 0) + endfor + + " Filter eof processes. + call filter(context.source__processes, '!v:val.eof') + + if empty(context.source__processes) + \ && context.source__number == context.source__max_bundles + break + endif + endwhile + finally + let &l:statusline = statusline_save + endtry + + return [context.source__synced_bundles, + \ context.source__errored_bundles] +endfunction"}}} + +function! s:check_update_init(bundle, context, is_unite) abort "{{{ + let a:context.source__number += 1 + + let num = a:context.source__number + let max = a:context.source__max_bundles + + let type = neobundle#config#get_types(a:bundle.type) + let cmd = has_key(type, 'get_revision_remote_command') ? + \ type.get_revision_remote_command(a:bundle) : '' + if cmd == '' || !isdirectory(a:bundle.path) + return + endif + + let message = printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, a:bundle.name, cmd) + + call neobundle#installer#log(message, a:is_unite) + + let cwd = getcwd() + try + " Cd to bundle path. + call neobundle#util#cd(a:bundle.path) + + let process = { + \ 'number' : num, + \ 'bundle' : a:bundle, + \ 'output' : '', + \ 'status' : -1, + \ 'eof' : 0, + \ 'start_time' : localtime(), + \ } + if neobundle#util#has_vimproc() + let process.proc = vimproc#pgroup_open(vimproc#util#iconv( + \ cmd, &encoding, 'char'), 0, 2) + + " Close handles. + call process.proc.stdin.close() + " call process.proc.stderr.close() + else + let process.output = neobundle#util#system(cmd) + let process.status = neobundle#util#get_last_status() + endif + finally + call neobundle#util#cd(cwd) + endtry + + call add(a:context.source__processes, process) +endfunction "}}} + +function! s:check_update_process(context, process, is_unite) abort "{{{ + if neobundle#util#has_vimproc() && has_key(a:process, 'proc') + let is_timeout = (localtime() - a:process.start_time) + \ >= a:process.bundle.install_process_timeout + let a:process.output .= vimproc#util#iconv( + \ a:process.proc.stdout.read(-1, 300), 'char', &encoding) + if !a:process.proc.stdout.eof && !is_timeout + return + endif + call a:process.proc.stdout.close() + + let status = a:process.proc.waitpid()[1] + else + let is_timeout = 0 + let status = a:process.status + endif + + let num = a:process.number + let max = a:context.source__max_bundles + let bundle = a:process.bundle + + let remote_rev = matchstr(a:process.output, '^\S\+') + + let revision_save = bundle.rev + try + " Get HEAD revision + let rev = neobundle#installer#get_revision_number(bundle) + finally + let bundle.rev = revision_save + let bundle.remote_rev = remote_rev + endtry + + if is_timeout || status + let message = printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, bundle.name, 'Error') + call neobundle#installer#log(message, a:is_unite) + call neobundle#installer#error(bundle.path) + call neobundle#installer#error( + \ (is_timeout ? 'Process timeout.' : + \ split(a:process.output, '\n'))) + elseif remote_rev != '' && remote_rev !=# rev + call add(a:context.source__updated_bundles, + \ bundle) + endif + + let a:process.eof = 1 +endfunction"}}} + +function! s:check_really_clean(dirs) abort "{{{ + echo join(a:dirs, "\n") + + return input('Are you sure you want to remove ' + \ .len(a:dirs).' bundles? [y/n] : ') =~? 'y' +endfunction"}}} + +function! s:update_tags() abort "{{{ + let bundles = [{ 'rtp' : neobundle#get_runtime_dir()}] + \ + neobundle#config#get_enabled_bundles() + call neobundle#util#copy_bundle_files(bundles, 'doc') + + call neobundle#util#writefile('tags_info', + \ sort(map(neobundle#config#get_neobundles(), 'v:val.name'))) + + silent execute 'helptags' fnameescape(neobundle#get_tags_dir()) +endfunction"}}} + +function! s:has_doc(path) abort "{{{ + return a:path != '' && + \ isdirectory(a:path.'/doc') + \ && (!filereadable(a:path.'/doc/tags') + \ || filewritable(a:path.'/doc/tags')) + \ && (!filereadable(a:path.'/doc/tags-??') + \ || filewritable(a:path.'/doc/tags-??')) + \ && (glob(a:path.'/doc/*.txt') != '' + \ || glob(a:path.'/doc/*.??x') != '') +endfunction"}}} + +" Vimproc is first. +function! s:cmp_vimproc(a, b) abort "{{{ + return !(a:a.name ==# 'vimproc' || a:a.name ==# 'vimproc.vim') +endfunction"}}} + +let &cpo = s:save_cpo +unlet s:save_cpo diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/config.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/config.vim new file mode 100644 index 0000000..28b629b --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/config.vim @@ -0,0 +1,761 @@ +"============================================================================= +" FILE: config.vim +" AUTHOR: Shougo Matsushita +" 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('s:neobundles') + let s:within_block = 0 + let s:lazy_rtp_bundles = [] + let s:neobundles = {} + let neobundle#tapped = {} +endif + +function! neobundle#config#init() abort "{{{ + if neobundle#config#within_block() + call neobundle#util#print_error( + \ 'neobundle#begin()/neobundle#end() usage is invalid.') + call neobundle#util#print_error( + \ 'Please check your .vimrc.') + return + endif + + augroup neobundle + autocmd VimEnter * call s:on_vim_enter() + augroup END + + call s:filetype_off() + + let s:within_block = 1 + let s:lazy_rtp_bundles = [] + + " Load extra bundles configuration. + call neobundle#config#load_extra_bundles() +endfunction"}}} +function! neobundle#config#append() abort "{{{ + if neobundle#config#within_block() + call neobundle#util#print_error( + \ 'neobundle#begin()/neobundle#end() usage is invalid.') + call neobundle#util#print_error( + \ 'Please check your .vimrc.') + return + endif + + if neobundle#get_rtp_dir() == '' + call neobundle#util#print_error( + \ 'You must call neobundle#begin() before.') + call neobundle#util#print_error( + \ 'Please check your .vimrc.') + return + endif + + call s:filetype_off() + + let s:within_block = 1 + let s:lazy_rtp_bundles = [] +endfunction"}}} +function! neobundle#config#final() abort "{{{ + if !neobundle#config#within_block() + call neobundle#util#print_error( + \ 'neobundle#begin()/neobundle#end() usage is invalid.') + call neobundle#util#print_error( + \ 'Please check your .vimrc.') + return + endif + + " Join to the tail in runtimepath. + let rtps = neobundle#util#split_rtp(&runtimepath) + let index = index(rtps, neobundle#get_rtp_dir()) + if index < 0 + call neobundle#util#print_error( + \ 'Invalid runtimepath is detected.') + call neobundle#util#print_error( + \ 'Please check your .vimrc.') + return + endif + for bundle in filter(s:lazy_rtp_bundles, + \ 'isdirectory(v:val.rtp) && !v:val.disabled') + let bundle.sourced = 1 + call insert(rtps, bundle.rtp, index) + let index += 1 + + if isdirectory(bundle.rtp.'/after') + call add(rtps, s:get_rtp_after(bundle)) + endif + endfor + let &runtimepath = neobundle#util#join_rtp(rtps, &runtimepath, '') + + call neobundle#call_hook('on_source', s:lazy_rtp_bundles) + + let s:within_block = 0 + let s:lazy_rtp_bundles = [] +endfunction"}}} +function! neobundle#config#within_block() abort "{{{ + return s:within_block +endfunction"}}} + +function! neobundle#config#get(name) abort "{{{ + return get(s:neobundles, a:name, {}) +endfunction"}}} + +function! neobundle#config#get_neobundles() abort "{{{ + return values(s:neobundles) +endfunction"}}} + +function! neobundle#config#get_enabled_bundles() abort "{{{ + return filter(values(s:neobundles), + \ "!v:val.disabled") +endfunction"}}} + +function! neobundle#config#get_autoload_bundles() abort "{{{ + return filter(values(s:neobundles), + \ "!v:val.sourced && v:val.lazy && !v:val.disabled") +endfunction"}}} + +function! neobundle#config#source_bundles(bundles) abort "{{{ + if !empty(a:bundles) + call neobundle#config#source(map(copy(a:bundles), + \ "type(v:val) == type({}) ? v:val.name : v:val")) + endif +endfunction"}}} + +function! neobundle#config#check_not_exists(names, ...) abort "{{{ + " For infinite loop. + let self = get(a:000, 0, []) + + let _ = map(neobundle#get_not_installed_bundles(a:names), 'v:val.name') + for bundle in map(filter(copy(a:names), + \ 'index(self, v:val) < 0 && has_key(s:neobundles, v:val)'), + \ 's:neobundles[v:val]') + call add(self, bundle.name) + + if !empty(bundle.depends) + let _ += neobundle#config#check_not_exists( + \ map(copy(bundle.depends), 'v:val.name'), self) + endif + endfor + + if len(_) > 1 + let _ = neobundle#util#uniq(_) + endif + + return _ +endfunction"}}} + +function! neobundle#config#source(names, ...) abort "{{{ + let is_force = get(a:000, 0, 1) + + let bundles = neobundle#config#search( + \ neobundle#util#convert2list(a:names)) + + let bundles = filter(bundles, "!v:val.disabled && !v:val.sourced") + if empty(bundles) + return + endif + + let filetype_before = neobundle#util#redir("autocmd FileType") + + let reset_ftplugin = 0 + for bundle in bundles + let bundle.sourced = 1 + let bundle.disabled = 0 + + if !empty(bundle.dummy_commands) + for command in bundle.dummy_commands + silent! execute 'delcommand' command + endfor + let bundle.dummy_commands = [] + endif + + if !empty(bundle.dummy_mappings) + for [mode, mapping] in bundle.dummy_mappings + silent! execute mode.'unmap' mapping + endfor + let bundle.dummy_mappings = [] + endif + + call neobundle#config#rtp_add(bundle) + + if exists('g:loaded_neobundle') || is_force + try + call s:on_source(bundle) + catch + call neobundle#util#print_error( + \ 'Uncaught error while sourcing "' . bundle.name . + \ '": '.v:exception . ' in ' . v:throwpoint) + endtry + endif + + call neobundle#autoload#_source(bundle.name) + + if !reset_ftplugin + let reset_ftplugin = s:is_reset_ftplugin(&filetype, bundle.rtp) + endif + endfor + + let filetype_after = neobundle#util#redir('autocmd FileType') + + if reset_ftplugin && &filetype != '' + if &verbose + call neobundle#util#print_error( + \ "Neobundle: resetting ftplugin, after loading bundles:" + \ .join(map(copy(bundles), 'v:val.name'), ", ")) + endif + call s:reset_ftplugin() + elseif filetype_before !=# filetype_after + if &verbose + call neobundle#util#print_error( + \ "Neobundle: FileType autocommand triggered by:" + \ .join(map(copy(bundles), 'v:val.name'), ", ")) + endif + execute 'doautocmd FileType' &filetype + endif + + if exists('g:loaded_neobundle') + call neobundle#call_hook('on_post_source', bundles) + endif +endfunction"}}} + +function! neobundle#config#disable(...) abort "{{{ + let bundle_names = neobundle#config#search(a:000) + if empty(bundle_names) + call neobundle#util#print_error( + \ 'Disabled bundles ' . string(a:000) . ' are not found.') + return + endif + + for bundle in bundle_names + call neobundle#config#rtp_rm(bundle) + let bundle.refcnt -= 1 + + if bundle.refcnt <= 0 + if bundle.sourced + call neobundle#util#print_error( + \ bundle.name . ' is already sourced. Cannot be disabled.') + continue + endif + + let bundle.disabled = 1 + endif + endfor +endfunction"}}} + +function! neobundle#config#is_disabled(name) abort "{{{ + return get(neobundle#config#get(a:name), 'disabled', 1) +endfunction"}}} + +function! neobundle#config#is_sourced(name) abort "{{{ + return get(neobundle#config#get(a:name), 'sourced', 0) +endfunction"}}} + +function! neobundle#config#is_installed(name) abort "{{{ + return isdirectory(get(neobundle#config#get(a:name), 'path', '')) +endfunction"}}} + +function! neobundle#config#rm(bundle) abort "{{{ + call neobundle#config#rtp_rm(a:bundle) + call remove(s:neobundles, a:bundle.name) +endfunction"}}} +function! neobundle#config#rmdir(path) abort "{{{ + for bundle in filter(neobundle#config#get_neobundles(), + \ 'v:val.path ==# a:path') + call neobundle#config#rm(bundle) + endfor +endfunction"}}} + +function! neobundle#config#get_types(...) abort "{{{ + let type = get(a:000, 0, '') + + if type ==# 'git' + if !exists('s:neobundle_type_git') + let s:neobundle_type_git = neobundle#types#git#define() + endif + + return s:neobundle_type_git + endif + + if !exists('s:neobundle_types') + " Load neobundle types. + let s:neobundle_types = [] + for list in map(split(globpath(&runtimepath, + \ 'autoload/neobundle/types/*.vim', 1), '\n'), + \ "neobundle#util#convert2list( + \ neobundle#types#{fnamemodify(v:val, ':t:r')}#define())") + let s:neobundle_types += list + endfor + + let s:neobundle_types = neobundle#util#uniq( + \ s:neobundle_types, 'v:val.name') + endif + + return (type == '') ? s:neobundle_types : + \ get(filter(copy(s:neobundle_types), 'v:val.name ==# type'), 0, {}) +endfunction"}}} + +function! neobundle#config#rtp_rm_all_bundles() abort "{{{ + call filter(values(s:neobundles), 'neobundle#config#rtp_rm(v:val)') +endfunction"}}} + +function! neobundle#config#rtp_rm(bundle) abort "{{{ + execute 'set rtp-='.fnameescape(a:bundle.rtp) + if isdirectory(a:bundle.rtp.'/after') + execute 'set rtp-='.s:get_rtp_after(a:bundle) + endif + + " Remove from lazy runtimepath + call filter(s:lazy_rtp_bundles, "v:val.name !=# a:bundle.name") +endfunction"}}} + +function! neobundle#config#rtp_add(bundle) abort "{{{ + if has_key(s:neobundles, a:bundle.name) + call neobundle#config#rtp_rm(s:neobundles[a:bundle.name]) + endif + + if s:within_block && !a:bundle.force + " Add rtp lazily. + call add(s:lazy_rtp_bundles, a:bundle) + return + endif + + let rtp = a:bundle.rtp + if isdirectory(rtp) + " Join to the tail in runtimepath. + let rtps = neobundle#util#split_rtp(&runtimepath) + let &runtimepath = neobundle#util#join_rtp( + \ insert(rtps, rtp, index(rtps, neobundle#get_rtp_dir())), + \ &runtimepath, rtp) + endif + if isdirectory(rtp.'/after') + execute 'set rtp+='.s:get_rtp_after(a:bundle) + endif + let a:bundle.sourced = 1 + + call neobundle#call_hook('on_source', a:bundle) +endfunction"}}} + +function! neobundle#config#search(bundle_names, ...) abort "{{{ + " For infinite loop. + let self = get(a:000, 0, []) + + let bundle_names = filter(copy(a:bundle_names), 'index(self, v:val) < 0') + if empty(bundle_names) + return [] + endif + + let _ = [] + let bundles = len(bundle_names) != 1 ? + \ filter(neobundle#config#get_neobundles(), + \ 'index(a:bundle_names, v:val.name) >= 0') : + \ has_key(s:neobundles, bundle_names[0]) ? + \ [s:neobundles[bundle_names[0]]] : [] + for bundle in bundles + call add(self, bundle.name) + + if !empty(bundle.depends) + let _ += neobundle#config#search( + \ map(copy(bundle.depends), 'v:val.name'), self) + endif + call add(_, bundle) + endfor + + if len(_) > 1 + let _ = neobundle#util#uniq(_) + endif + + return _ +endfunction"}}} + +function! neobundle#config#search_simple(bundle_names) abort "{{{ + return filter(neobundle#config#get_neobundles(), + \ 'index(a:bundle_names, v:val.name) >= 0') +endfunction"}}} + +function! neobundle#config#fuzzy_search(bundle_names) abort "{{{ + let bundles = [] + for name in a:bundle_names + let bundles += filter(neobundle#config#get_neobundles(), + \ 'stridx(v:val.name, name) >= 0') + endfor + + let _ = [] + for bundle in bundles + if !empty(bundle.depends) + let _ += neobundle#config#search( + \ map(copy(bundle.depends), 'v:val.name')) + endif + call add(_, bundle) + endfor + + if len(_) > 1 + let _ = neobundle#util#uniq(_) + endif + + return _ +endfunction"}}} + +function! neobundle#config#load_extra_bundles() abort "{{{ + let path = neobundle#get_neobundle_dir() . '/extra_bundles.vim' + + if filereadable(path) + execute 'source' fnameescape(path) + endif +endfunction"}}} + +function! neobundle#config#save_direct(arg) abort "{{{ + if neobundle#util#is_sudo() + call neobundle#util#print_error( + \ '"sudo vim" is detected. This feature is disabled.') + return + endif + + let path = neobundle#get_neobundle_dir() . '/extra_bundles.vim' + let bundles = filereadable(path) ? readfile(path) : [] + call writefile(add(bundles, 'NeoBundle ' . a:arg), path) +endfunction"}}} + +function! neobundle#config#set(name, dict) abort "{{{ + let bundle = neobundle#config#get(a:name) + if empty(bundle) + call neobundle#util#print_error( + \ 'Plugin name "' . a:name . '" is not defined.') + return + endif + if bundle.sourced + return + endif + if !neobundle#config#within_block() + call neobundle#util#print_error( + \ 'You must call neobundle#config() ' + \ .'within neobundle#begin()/neobundle#end() block.') + return + endif + + call neobundle#config#add( + \ neobundle#init#_bundle(extend(bundle, a:dict))) +endfunction"}}} + +function! neobundle#config#add(bundle) abort "{{{ + if empty(a:bundle) + return + endif + + let bundle = a:bundle + + let prev_bundle = get(s:neobundles, bundle.name, {}) + if !empty(prev_bundle) && prev_bundle.lazy != bundle.lazy + let bundle.lazy = 0 + endif + + if !empty(bundle.depends) + call s:add_depends(bundle) + endif + + if !empty(prev_bundle) + if prev_bundle.sourced + return + endif + + call neobundle#config#rtp_rm(prev_bundle) + endif + let s:neobundles[bundle.name] = bundle + + if bundle.disabled + " Ignore load. + return + endif + + if !bundle.lazy && bundle.rtp != '' + if !has('vim_starting') + " Load automatically. + call neobundle#config#source(bundle.name, bundle.force) + else + call neobundle#config#rtp_add(bundle) + + if bundle.force + execute 'runtime!' bundle.rtp . '/plugin/**/*.vim' + endif + endif + elseif bundle.lazy && !bundle.sourced + if !empty(bundle.on_cmd) + call s:add_dummy_commands(bundle) + endif + + if !empty(bundle.on_map) + call s:add_dummy_mappings(bundle) + endif + endif +endfunction"}}} + +function! neobundle#config#tsort(bundles) abort "{{{ + let sorted = [] + let mark = {} + for target in a:bundles + call s:tsort_impl(target, a:bundles, mark, sorted) + endfor + + return sorted +endfunction"}}} + +function! neobundle#config#get_lazy_rtp_bundles() abort "{{{ + return s:lazy_rtp_bundles +endfunction"}}} + +function! neobundle#config#check_commands(commands) abort "{{{ + " Environment check. + if type(a:commands) == type([]) + \ || type(a:commands) == type('') + let commands = a:commands + elseif neobundle#util#is_windows() && has_key(a:commands, 'windows') + let commands = a:commands.windows + elseif neobundle#util#is_mac() && has_key(a:commands, 'mac') + let commands = a:commands.mac + elseif neobundle#util#is_cygwin() && has_key(a:commands, 'cygwin') + let commands = a:commands.cygwin + elseif !neobundle#util#is_windows() && has_key(a:commands, 'unix') + let commands = a:commands.unix + elseif has_key(a:commands, 'others') + let commands = a:commands.others + else + " Invalid. + return 0 + endif + + for command in neobundle#util#convert2list(commands) + if !executable(command) + return 1 + endif + endfor +endfunction"}}} + +function! s:tsort_impl(target, bundles, mark, sorted) abort "{{{ + if has_key(a:mark, a:target.name) + return + endif + + let a:mark[a:target.name] = 1 + for depend in get(a:target, 'depends', []) + call s:tsort_impl(get(s:neobundles, depend.name, depend), + \ a:bundles, a:mark, a:sorted) + endfor + + call add(a:sorted, a:target) +endfunction"}}} + +function! s:on_vim_enter() abort "{{{ + if !empty(s:lazy_rtp_bundles) + call neobundle#util#print_error( + \ 'neobundle#begin() was called without calling ' . + \ 'neobundle#end() in .vimrc.') + " We're past the point of plugins being sourced, so don't bother + " trying to recover. + return + endif + + call neobundle#call_hook('on_post_source') +endfunction"}}} + +function! s:add_depends(bundle) abort "{{{ + " Add depends. + for depend in a:bundle.depends + let depend.lazy = a:bundle.lazy + + if !has_key(s:neobundles, depend.name) + call neobundle#config#add(depend) + else + let depend_bundle = s:neobundles[depend.name] + " Add reference count + let depend_bundle.refcnt += 1 + + if (a:bundle.sourced && !depend_bundle.sourced) || !a:bundle.lazy + " Load automatically. + call neobundle#config#source(depend.name, depend.force) + endif + endif + endfor +endfunction"}}} + +function! s:add_dummy_commands(bundle) abort "{{{ + let a:bundle.dummy_commands = [] + for command in map(copy(a:bundle.on_cmd), " + \ type(v:val) == type('') ? + \ { 'name' : v:val } : v:val + \") + + for name in neobundle#util#convert2list(command.name) + " Define dummy commands. + silent! execute 'command ' + \ . '-complete=customlist,neobundle#autoload#_command_dummy_complete' + \ . ' -bang -bar -range -nargs=*' name printf( + \ "call neobundle#autoload#_command(%s, %s, , + \ expand(''), expand(''), expand(''))", + \ string(name), string(a:bundle.name)) + + call add(a:bundle.dummy_commands, name) + endfor + endfor +endfunction"}}} +function! s:add_dummy_mappings(bundle) abort "{{{ + let a:bundle.dummy_mappings = [] + for [modes, mappings] in map(copy(a:bundle.on_map), " + \ type(v:val) == type([]) ? + \ [v:val[0], v:val[1:]] : ['nxo', [v:val]] + \ ") + if mappings ==# [''] + " Use plugin name. + let mappings = ['(' . a:bundle.normalized_name] + if stridx(a:bundle.normalized_name, '-') >= 0 + " The plugin mappings may use "_" instead of "-". + call add(mappings, '(' . + \ substitute(a:bundle.normalized_name, '-', '_', 'g')) + endif + endif + + for mapping in mappings + " Define dummy mappings. + for mode in filter(split(modes, '\zs'), + \ "index(['n', 'v', 'x', 'o', 'i', 'c'], v:val) >= 0") + let mapping_str = substitute(mapping, '<', '', 'g') + silent! execute mode.'noremap ' mapping printf( + \ (mode ==# 'c' ? "\=" : + \ (mode ==# 'i' ? "\:" : ":\")."call "). + \ "neobundle#autoload#_mapping(%s, %s, %s)", + \ string(mapping_str), string(a:bundle.name), string(mode)) + + call add(a:bundle.dummy_mappings, [mode, mapping]) + endfor + endfor + endfor +endfunction"}}} + +function! s:on_source(bundle) abort "{{{ + if a:bundle.verbose && a:bundle.lazy + redraw + echo 'source:' a:bundle.name + endif + + " Reload script files. + for directory in filter(['plugin', 'after/plugin'], + \ "isdirectory(a:bundle.rtp.'/'.v:val)") + for file in split(glob(a:bundle.rtp.'/'.directory.'/**/*.vim'), '\n') + " Note: "silent!" is required to ignore E122, E174 and E227. + " try/catching them aborts sourcing of the file. + " "unsilent" then displays any messages while sourcing. + execute 'silent! unsilent source' fnameescape(file) + endfor + endfor + + if !has('vim_starting') + if exists('#'.a:bundle.augroup.'#VimEnter') + execute 'doautocmd' a:bundle.augroup 'VimEnter' + endif + + if has('gui_running') && &term ==# 'builtin_gui' + \ && exists('#'.a:bundle.augroup.'#GUIEnter') + execute 'doautocmd' a:bundle.augroup 'GUIEnter' + endif + endif + + if a:bundle.verbose && a:bundle.lazy + redraw + echo 'sourced:' a:bundle.name + endif +endfunction"}}} + +function! s:clear_dummy(bundle) abort "{{{ +endfunction"}}} + +function! s:is_reset_ftplugin(filetype, rtp) abort "{{{ + for filetype in split(a:filetype, '\.') + for directory in ['ftplugin', 'indent', + \ 'after/ftplugin', 'after/indent'] + let base = a:rtp . '/' . directory + if filereadable(base.'/'.filetype.'.vim') || + \ (directory =~# 'ftplugin$' && + \ isdirectory(base . '/' . filetype) || + \ glob(base.'/'.filetype.'_*.vim') != '') + return 1 + endif + endfor + endfor + + return 0 +endfunction"}}} + +function! s:reset_ftplugin() abort "{{{ + let filetype_out = s:filetype_off() + + if filetype_out =~# 'detection:ON' + \ && filetype_out =~# 'plugin:ON' + \ && filetype_out =~# 'indent:ON' + silent! filetype plugin indent on + else + if filetype_out =~# 'detection:ON' + silent! filetype on + endif + + if filetype_out =~# 'plugin:ON' + silent! filetype plugin on + endif + + if filetype_out =~# 'indent:ON' + silent! filetype indent on + endif + endif + + if filetype_out =~# 'detection:ON' + filetype detect + endif + + " Reload filetype plugins. + let &l:filetype = &l:filetype + + " Recall FileType autocmd + execute 'doautocmd FileType' &filetype +endfunction"}}} + +function! s:filetype_off() abort "{{{ + let filetype_out = neobundle#util#redir('filetype') + + if filetype_out =~# 'plugin:ON' + \ || filetype_out =~# 'indent:ON' + filetype plugin indent off + endif + + if filetype_out =~# 'detection:ON' + filetype off + endif + + return filetype_out +endfunction"}}} + +function! s:get_rtp_after(bundle) abort "{{{ + return substitute( + \ fnameescape(a:bundle.rtp . '/after'), '//', '/', 'g') +endfunction"}}} + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: foldmethod=marker diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/init.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/init.vim new file mode 100644 index 0000000..fa5125f --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/init.vim @@ -0,0 +1,300 @@ +"============================================================================= +" FILE: init.vim +" AUTHOR: Shougo Matsushita +" 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 + diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/installer.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/installer.vim new file mode 100644 index 0000000..41a70a9 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/installer.vim @@ -0,0 +1,892 @@ +"============================================================================= +" FILE: installer.vim +" AUTHOR: Shougo Matsushita +" 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:install_info_version = '3.0' + +let s:log = [] +let s:updates_log = [] + +function! neobundle#installer#update(bundles) abort "{{{ + if neobundle#util#is_sudo() + call neobundle#util#print_error( + \ '"sudo vim" is detected. This feature is disabled.') + return + endif + + let all_bundles = neobundle#config#get_enabled_bundles() + + call neobundle#commands#helptags(all_bundles) + call s:reload(filter(copy(a:bundles), + \ "v:val.sourced && !v:val.disabled && v:val.rtp != ''")) + + call s:save_install_info(all_bundles) + + let lazy_bundles = filter(copy(all_bundles), 'v:val.lazy') + call neobundle#util#merge_bundle_files( + \ lazy_bundles, 'ftdetect') + call neobundle#util#merge_bundle_files( + \ lazy_bundles, 'after/ftdetect') + + " For neovim remote plugins + NeoBundleRemotePlugins +endfunction"}}} + +function! neobundle#installer#build(bundle) abort "{{{ + if !empty(a:bundle.build_commands) + \ && neobundle#config#check_commands(a:bundle.build_commands) + call neobundle#installer#log( + \ printf('|%s| ' . + \ 'Build dependencies not met. Skipped', a:bundle.name)) + return 0 + endif + + " Environment check. + let build = get(a:bundle, 'build', {}) + if type(build) == type('') + let cmd = build + elseif neobundle#util#is_windows() && has_key(build, 'windows') + let cmd = build.windows + elseif neobundle#util#is_mac() && has_key(build, 'mac') + let cmd = build.mac + elseif neobundle#util#is_cygwin() && has_key(build, 'cygwin') + let cmd = build.cygwin + elseif !neobundle#util#is_windows() && has_key(build, 'linux') + \ && !executable('gmake') + let cmd = build.linux + elseif !neobundle#util#is_windows() && has_key(build, 'unix') + let cmd = build.unix + elseif has_key(build, 'others') + let cmd = build.others + else + return 0 + endif + + call neobundle#installer#log('Building...') + + let cwd = getcwd() + try + call neobundle#util#cd(a:bundle.path) + + if !neobundle#util#has_vimproc() + let result = neobundle#util#system(cmd) + + if neobundle#util#get_last_status() + call neobundle#installer#error(result) + else + call neobundle#installer#log(result) + endif + else + call s:async_system(cmd) + endif + catch + " Build error from vimproc. + let message = (v:exception !~# '^Vim:')? + \ v:exception : v:exception . ' ' . v:throwpoint + call neobundle#installer#error(message) + + return 1 + finally + call neobundle#util#cd(cwd) + endtry + + return neobundle#util#get_last_status() +endfunction"}}} + +function! neobundle#installer#reinstall(bundles) abort "{{{ + let bundles = neobundle#util#uniq(a:bundles) + + for bundle in bundles + if bundle.type ==# 'none' + \ || bundle.local + \ || bundle.normalized_name ==# 'neobundle' + \ || (bundle.sourced && + \ index(['vimproc', 'unite'], bundle.normalized_name) >= 0) + call neobundle#installer#error( + \ printf('|%s| Cannot reinstall the plugin!', bundle.name)) + continue + endif + + " Reinstall. + call neobundle#installer#log( + \ printf('|%s| Reinstalling...', bundle.name)) + + " Save info. + let arg = copy(bundle.orig_arg) + + " Remove. + call neobundle#commands#clean(1, bundle.name) + + call call('neobundle#parser#bundle', [arg]) + endfor + + call s:save_install_info(neobundle#config#get_neobundles()) + + " Install. + call neobundle#commands#install(0, + \ join(map(copy(bundles), 'v:val.name'))) + + call neobundle#installer#update(bundles) +endfunction"}}} + +function! neobundle#installer#get_reinstall_bundles(bundles) abort "{{{ + call neobundle#installer#_load_install_info(a:bundles) + + let reinstall_bundles = filter(copy(a:bundles), + \ "neobundle#config#is_installed(v:val.name) + \ && v:val.type !=# 'none' + \ && !v:val.local + \ && v:val.path ==# v:val.installed_path + \ && v:val.uri !=# v:val.installed_uri") + if !empty(reinstall_bundles) + call neobundle#util#print_error( + \ 'Reinstall bundles are detected!') + + for bundle in reinstall_bundles + echomsg printf('%s: %s -> %s', + \ bundle.name, bundle.installed_uri, bundle.uri) + endfor + + let cwd = neobundle#util#substitute_path_separator(getcwd()) + let warning_bundles = map(filter(copy(reinstall_bundles), + \ 'v:val.path ==# cwd'), 'v:val.path') + if !empty(warning_bundles) + call neobundle#util#print_error( + \ 'Warning: current directory is the + \ reinstall bundles directory! ' . string(warning_bundles)) + endif + let ret = confirm('Reinstall bundles now?', "yes\nNo", 2) + redraw + if ret != 1 + return [] + endif + endif + + return reinstall_bundles +endfunction"}}} + +function! neobundle#installer#get_updated_bundles_message(bundles) abort "{{{ + let msg = '' + + let installed_bundles = filter(copy(a:bundles), + \ "v:val.old_rev == ''") + if !empty(installed_bundles) + let msg .= "\nInstalled bundles:\n". + \ join(map(copy(installed_bundles), + \ "' ' . v:val.name"), "\n") + endif + + let updated_bundles = filter(copy(a:bundles), + \ "v:val.old_rev != ''") + if !empty(updated_bundles) + let msg .= "\nUpdated bundles:\n". + \ join(map(updated_bundles, + \ "' ' . v:val.name . (v:val.commit_count == 0 ? '' + \ : printf('(%d change%s)', + \ v:val.commit_count, + \ (v:val.commit_count == 1 ? '' : 's'))) + \ . (v:val.uri =~ '^\\h\\w*://github.com/' ? \"\\n\" + \ . printf(' %s/compare/%s...%s', + \ substitute(substitute(v:val.uri, '\\.git$', '', ''), + \ '^\\h\\w*:', 'https:', ''), + \ v:val.old_rev, v:val.new_rev) : '')") + \ , "\n") + endif + + return msg +endfunction"}}} + +function! neobundle#installer#get_errored_bundles_message(bundles) abort "{{{ + if empty(a:bundles) + return '' + endif + + let msg = "\nError installing bundles:\n".join( + \ map(copy(a:bundles), "' ' . v:val.name"), "\n") + let msg .= "\n" + let msg .= "Please read the error message log with the :message command.\n" + + return msg +endfunction"}}} + +function! neobundle#installer#get_sync_command(bang, bundle, number, max) abort "{{{ + let type = neobundle#config#get_types(a:bundle.type) + if empty(type) + return ['E: Unknown Type', ''] + endif + + let is_directory = isdirectory(a:bundle.path) + + let cmd = type.get_sync_command(a:bundle) + + if cmd == '' + return ['', 'Not supported sync action.'] + elseif (is_directory && !a:bang + \ && a:bundle.install_rev ==# + \ neobundle#installer#get_revision_number(a:bundle)) + return ['', 'Already installed.'] + endif + + let message = printf('(%'.len(a:max).'d/%d): |%s| %s', + \ a:number, a:max, a:bundle.name, cmd) + + return [cmd, message] +endfunction"}}} + +function! neobundle#installer#get_revision_lock_command(bang, bundle, number, max) abort "{{{ + let type = neobundle#config#get_types(a:bundle.type) + if empty(type) + return ['E: Unknown Type', ''] + endif + + let cmd = type.get_revision_lock_command(a:bundle) + + if cmd == '' + return ['', ''] + endif + + return [cmd, ''] +endfunction"}}} + +function! neobundle#installer#get_revision_number(bundle) abort "{{{ + let cwd = getcwd() + let type = neobundle#config#get_types(a:bundle.type) + + if !isdirectory(a:bundle.path) + \ || !has_key(type, 'get_revision_number_command') + return '' + endif + + let cmd = type.get_revision_number_command(a:bundle) + if cmd == '' + return '' + endif + + try + call neobundle#util#cd(a:bundle.path) + + let rev = neobundle#util#system(cmd) + + if type.name ==# 'vba' || type.name ==# 'raw' + " If rev is ok, the output is the checksum followed by the filename + " separated by two spaces. + let pat = '^[0-9a-f]\+ ' . a:bundle.path . '/' . + \ fnamemodify(a:bundle.uri, ':t') . '$' + return (rev =~# pat) ? matchstr(rev, '^[0-9a-f]\+') : '' + else + " If rev contains spaces, it is error message + return (rev !~ '\s') ? rev : '' + endif + finally + call neobundle#util#cd(cwd) + endtry +endfunction"}}} + +function! s:get_commit_date(bundle) abort "{{{ + let cwd = getcwd() + try + let type = neobundle#config#get_types(a:bundle.type) + + if !isdirectory(a:bundle.path) || + \ !has_key(type, 'get_commit_date_command') + return 0 + endif + + call neobundle#util#cd(a:bundle.path) + + return neobundle#util#system( + \ type.get_commit_date_command(a:bundle)) + finally + call neobundle#util#cd(cwd) + endtry +endfunction"}}} + +function! neobundle#installer#get_updated_log_message(bundle, new_rev, old_rev) abort "{{{ + let cwd = getcwd() + try + let type = neobundle#config#get_types(a:bundle.type) + + call neobundle#util#cd(a:bundle.path) + + let log_command = has_key(type, 'get_log_command') ? + \ type.get_log_command(a:bundle, a:new_rev, a:old_rev) : '' + let log = (log_command != '' ? + \ neobundle#util#system(log_command) : '') + return log != '' ? log : + \ (a:old_rev == a:new_rev) ? '' + \ : printf('%s -> %s', a:old_rev, a:new_rev) + finally + call neobundle#util#cd(cwd) + endtry +endfunction"}}} + +function! neobundle#installer#sync(bundle, context, is_unite) abort "{{{ + let a:context.source__number += 1 + + let num = a:context.source__number + let max = a:context.source__max_bundles + + let before_one_day = localtime() - 60 * 60 * 24 + let before_one_week = localtime() - 60 * 60 * 24 * 7 + + if a:context.source__bang == 1 && + \ a:bundle.frozen + let [cmd, message] = ['', 'is frozen.'] + elseif a:context.source__bang == 1 && + \ a:bundle.uri ==# a:bundle.installed_uri && + \ a:bundle.updated_time < before_one_week + \ && a:bundle.checked_time >= before_one_day + let [cmd, message] = ['', 'Outdated plugin.'] + else + let [cmd, message] = + \ neobundle#installer#get_sync_command( + \ a:context.source__bang, a:bundle, + \ a:context.source__number, a:context.source__max_bundles) + endif + + if cmd == '' + " Skipped. + call neobundle#installer#log(s:get_skipped_message( + \ num, max, a:bundle, '', message), a:is_unite) + return + elseif cmd =~# '^E: ' + " Errored. + + call neobundle#installer#update_log( + \ printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, a:bundle.name, 'Error'), a:is_unite) + call neobundle#installer#error(cmd[3:]) + call add(a:context.source__errored_bundles, + \ a:bundle) + return + endif + + call neobundle#installer#log(message, a:is_unite) + + let cwd = getcwd() + try + let lang_save = $LANG + let $LANG = 'C' + + " Cd to bundle path. + call neobundle#util#cd(a:bundle.path) + + let rev = neobundle#installer#get_revision_number(a:bundle) + + let process = { + \ 'number' : num, + \ 'rev' : rev, + \ 'bundle' : a:bundle, + \ 'output' : '', + \ 'status' : -1, + \ 'eof' : 0, + \ 'start_time' : localtime(), + \ } + + if isdirectory(a:bundle.path) && !a:bundle.local + let rev_save = a:bundle.rev + try + " Force checkout HEAD revision. + " The repository may be checked out. + let a:bundle.rev = '' + + call neobundle#installer#lock_revision( + \ process, a:context, a:is_unite) + finally + let a:bundle.rev = rev_save + endtry + endif + + if has('nvim') && a:is_unite + " Use neovim async jobs + let process.proc = jobstart( + \ iconv(cmd, &encoding, 'char'), { + \ 'on_stdout' : function('s:job_handler'), + \ 'on_stderr' : function('s:job_handler'), + \ 'on_exit' : function('s:job_handler'), + \ }) + elseif neobundle#util#has_vimproc() + let process.proc = vimproc#pgroup_open(vimproc#util#iconv( + \ cmd, &encoding, 'char'), 0, 2) + + " Close handles. + call process.proc.stdin.close() + call process.proc.stderr.close() + else + let process.output = neobundle#util#system(cmd) + let process.status = neobundle#util#get_last_status() + endif + finally + let $LANG = lang_save + call neobundle#util#cd(cwd) + endtry + + call add(a:context.source__processes, process) +endfunction"}}} + +function! neobundle#installer#check_output(context, process, is_unite) abort "{{{ + if has('nvim') && a:is_unite && has_key(a:process, 'proc') + let is_timeout = (localtime() - a:process.start_time) + \ >= a:process.bundle.install_process_timeout + + if !has_key(s:job_info, a:process.proc) + return + endif + + let job = s:job_info[a:process.proc] + + if !job.eof && !is_timeout + let output = join(job.candidates[: -2], "\n") + if output != '' + let a:process.output .= output + call neobundle#util#redraw_echo(output) + endif + let job.candidates = job.candidates[-1:] + return + else + if is_timeout + call jobstop(a:process.proc) + endif + let output = join(job.candidates, "\n") + if output != '' + let a:process.output .= output + call neobundle#util#redraw_echo(output) + endif + let job.candidates = [] + endif + + let status = job.status + elseif neobundle#util#has_vimproc() && has_key(a:process, 'proc') + let is_timeout = (localtime() - a:process.start_time) + \ >= a:process.bundle.install_process_timeout + let output = vimproc#util#iconv( + \ a:process.proc.stdout.read(-1, 300), 'char', &encoding) + if output != '' + let a:process.output .= output + call neobundle#util#redraw_echo(output) + endif + if !a:process.proc.stdout.eof && !is_timeout + return + endif + call a:process.proc.stdout.close() + + let status = a:process.proc.waitpid()[1] + else + let is_timeout = 0 + let status = a:process.status + endif + + let num = a:process.number + let max = a:context.source__max_bundles + let bundle = a:process.bundle + + if bundle.rev != '' || !a:context.source__bang + " Restore revision. + let rev_save = bundle.rev + try + if !a:context.source__bang && bundle.rev == '' + " Checkout install_rev revision. + let bundle.rev = bundle.install_rev + endif + + call neobundle#installer#lock_revision( + \ a:process, a:context, a:is_unite) + finally + let bundle.rev = rev_save + endtry + endif + + let rev = neobundle#installer#get_revision_number(bundle) + + let updated_time = s:get_commit_date(bundle) + let bundle.checked_time = localtime() + + if is_timeout || status + let message = printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, bundle.name, 'Error') + call neobundle#installer#update_log(message, a:is_unite) + call neobundle#installer#error(bundle.path) + + call neobundle#installer#error( + \ (is_timeout ? 'Process timeout.' : + \ split(a:process.output, '\n'))) + + call add(a:context.source__errored_bundles, + \ bundle) + elseif a:process.rev ==# rev + if updated_time != 0 + let bundle.updated_time = updated_time + endif + + call neobundle#installer#log(s:get_skipped_message( + \ num, max, bundle, '', 'Same revision.'), a:is_unite) + else + call neobundle#installer#update_log( + \ printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, bundle.name, 'Updated'), a:is_unite) + if a:process.rev != '' + let log_messages = split( + \ neobundle#installer#get_updated_log_message( + \ bundle, rev, a:process.rev), '\n') + let bundle.commit_count = len(log_messages) + call call((!has('vim_starting') ? 'neobundle#installer#update_log' + \ : 'neobundle#installer#log'), [ + \ map(log_messages, "printf('|%s| ' . + \ substitute(v:val, '%', '%%', 'g'), bundle.name)"), + \ a:is_unite + \ ]) + else + let bundle.commit_count = 0 + endif + + if updated_time == 0 + let updated_time = bundle.checked_time + endif + let bundle.updated_time = updated_time + let bundle.installed_uri = bundle.uri + let bundle.revisions[updated_time] = rev + let bundle.old_rev = a:process.rev + let bundle.new_rev = rev + if neobundle#installer#build(bundle) + \ && confirm('Build failed. Uninstall "' + \ .bundle.name.'" now?', "yes\nNo", 2) == 1 + " Remove. + call neobundle#commands#clean(1, bundle.name) + else + call add(a:context.source__synced_bundles, bundle) + endif + endif + + let bundle.install_rev = rev + + let a:process.eof = 1 +endfunction"}}} + +function! neobundle#installer#lock_revision(process, context, is_unite) abort "{{{ + let num = a:process.number + let max = a:context.source__max_bundles + let bundle = a:process.bundle + + let bundle.new_rev = neobundle#installer#get_revision_number(bundle) + + let [cmd, message] = + \ neobundle#installer#get_revision_lock_command( + \ a:context.source__bang, bundle, num, max) + + if cmd == '' || bundle.new_rev ==# bundle.rev + " Skipped. + return 0 + elseif cmd =~# '^E: ' + " Errored. + call neobundle#installer#error(bundle.path) + call neobundle#installer#error(cmd[3:]) + return -1 + endif + + if bundle.rev != '' + call neobundle#installer#log( + \ printf('(%'.len(max).'d/%d): |%s| %s', + \ num, max, bundle.name, 'Locked'), a:is_unite) + + call neobundle#installer#log(message, a:is_unite) + endif + + let cwd = getcwd() + try + " Cd to bundle path. + call neobundle#util#cd(bundle.path) + + let result = neobundle#util#system(cmd) + let status = neobundle#util#get_last_status() + finally + call neobundle#util#cd(cwd) + endtry + + if status + call neobundle#installer#error(bundle.path) + call neobundle#installer#error(result) + return -1 + endif +endfunction"}}} + +function! neobundle#installer#get_release_revision(bundle, command) abort "{{{ + let cwd = getcwd() + let rev = '' + try + call neobundle#util#cd(a:bundle.path) + let rev = get(neobundle#util#sort_human( + \ split(neobundle#util#system(a:command), '\n')), -1, '') + finally + call neobundle#util#cd(cwd) + endtry + + return rev +endfunction"}}} + +function! s:save_install_info(bundles) abort "{{{ + let s:install_info = {} + for bundle in filter(copy(a:bundles), + \ "!v:val.local && has_key(v:val, 'updated_time')") + " Note: Don't save local repository. + let s:install_info[bundle.name] = { + \ 'checked_time' : bundle.checked_time, + \ 'updated_time' : bundle.updated_time, + \ 'installed_uri' : bundle.installed_uri, + \ 'installed_path' : bundle.path, + \ 'revisions' : bundle.revisions, + \ } + endfor + + call neobundle#util#writefile('install_info', + \ [s:install_info_version, string(s:install_info)]) + + " Save lock file + call s:save_lockfile(a:bundles) +endfunction"}}} + +function! neobundle#installer#_load_install_info(bundles) abort "{{{ + let install_info_path = + \ neobundle#get_neobundle_dir() . '/.neobundle/install_info' + if !exists('s:install_info') + call s:source_lockfile() + + let s:install_info = {} + + if filereadable(install_info_path) + try + let list = readfile(install_info_path) + let ver = list[0] + sandbox let s:install_info = eval(list[1]) + if ver !=# s:install_info_version + \ || type(s:install_info) != type({}) + let s:install_info = {} + endif + catch + endtry + endif + endif + + call map(a:bundles, "extend(v:val, get(s:install_info, v:val.name, { + \ 'checked_time' : localtime(), + \ 'updated_time' : localtime(), + \ 'installed_uri' : v:val.uri, + \ 'installed_path' : v:val.path, + \ 'revisions' : {}, + \}))") + + return s:install_info +endfunction"}}} + +function! s:get_skipped_message(number, max, bundle, prefix, message) abort "{{{ + let messages = [a:prefix . printf('(%'.len(a:max).'d/%d): |%s| %s', + \ a:number, a:max, a:bundle.name, 'Skipped')] + if a:message != '' + call add(messages, a:prefix . a:message) + endif + return messages +endfunction"}}} + +function! neobundle#installer#log(msg, ...) abort "{{{ + let msg = neobundle#util#convert2list(a:msg) + if empty(msg) + return + endif + call extend(s:log, msg) + + call s:append_log_file(msg) +endfunction"}}} + +function! neobundle#installer#update_log(msg, ...) abort "{{{ + let is_unite = get(a:000, 0, 0) + + if !(&filetype == 'unite' || is_unite) + call neobundle#util#redraw_echo(a:msg) + endif + + call neobundle#installer#log(a:msg) + + let s:updates_log += neobundle#util#convert2list(a:msg) +endfunction"}}} + +function! neobundle#installer#echomsg(msg) abort "{{{ + call neobundle#util#redraw_echomsg(a:msg) + + call neobundle#installer#log(a:msg) + + let s:updates_log += neobundle#util#convert2list(a:msg) +endfunction"}}} + +function! neobundle#installer#error(msg) abort "{{{ + let msgs = neobundle#util#convert2list(a:msg) + if empty(msgs) + return + endif + call extend(s:log, msgs) + call extend(s:updates_log, msgs) + + call neobundle#util#print_error(msgs) + call s:append_log_file(msgs) +endfunction"}}} + +function! s:append_log_file(msg) abort "{{{ + if g:neobundle#log_filename == '' + return + endif + + let msg = a:msg + " Appends to log file. + if filereadable(g:neobundle#log_filename) + let msg = readfile(g:neobundle#log_filename) + msg + endif + + let dir = fnamemodify(g:neobundle#log_filename, ':h') + if !isdirectory(dir) + call mkdir(dir, 'p') + endif + call writefile(msg, g:neobundle#log_filename) +endfunction"}}} + +function! neobundle#installer#get_log() abort "{{{ + return s:log +endfunction"}}} + +function! neobundle#installer#get_updates_log() abort "{{{ + return s:updates_log +endfunction"}}} + +function! neobundle#installer#clear_log() abort "{{{ + let s:log = [] + let s:updates_log = [] +endfunction"}}} + +function! neobundle#installer#get_progress_message(bundle, number, max) abort "{{{ + return printf('(%'.len(a:max).'d/%d) [%-20s] %s', + \ a:number, a:max, + \ repeat('=', (a:number*20/a:max)), a:bundle.name) +endfunction"}}} + +function! neobundle#installer#get_tags_info() abort "{{{ + let path = neobundle#get_neobundle_dir() . '/.neobundle/tags_info' + if !filereadable(path) + return [] + endif + + return readfile(path) +endfunction"}}} + +function! s:save_lockfile(bundles) abort "{{{ + let path = neobundle#get_neobundle_dir() . '/NeoBundle.lock' + let dir = fnamemodify(path, ':h') + if !isdirectory(dir) + call mkdir(dir, 'p') + endif + + return writefile(sort(map(filter(map(copy(a:bundles), + \ '[v:val.name, neobundle#installer#get_revision_number(v:val)]'), + \ "v:val[1] != '' && v:val[1] !~ '\s'"), + \ "printf('NeoBundleLock %s %s', + \ escape(v:val[0], ' \'), v:val[1])")), path) +endfunction"}}} + +function! s:source_lockfile() abort "{{{ + let path = neobundle#get_neobundle_dir() . '/NeoBundle.lock' + if filereadable(path) + execute 'source' fnameescape(path) + endif +endfunction"}}} + +function! s:reload(bundles) abort "{{{ + if empty(a:bundles) + return + endif + + call filter(copy(a:bundles), 'neobundle#config#rtp_add(v:val)') + + silent! runtime! ftdetect/**/*.vim + silent! runtime! after/ftdetect/**/*.vim + silent! runtime! plugin/**/*.vim + silent! runtime! after/plugin/**/*.vim + + " Call hooks. + call neobundle#call_hook('on_post_source', a:bundles) +endfunction"}}} + +let s:job_info = {} +function! s:job_handler(job_id, data, event) abort "{{{ + if !has_key(s:job_info, a:job_id) + let s:job_info[a:job_id] = { + \ 'candidates' : [], + \ 'eof' : 0, + \ 'status' : -1, + \ } + endif + + let job = s:job_info[a:job_id] + + if a:event ==# 'exit' + let job.eof = 1 + let job.status = a:data + return + endif + + let lines = a:data + + let candidates = job.candidates + if !empty(lines) && lines[0] != "\n" && !empty(job.candidates) + " Join to the previous line + let candidates[-1] .= lines[0] + call remove(lines, 0) + endif + + let candidates += map(lines, "iconv(v:val, 'char', &encoding)") +endfunction"}}} + +function! s:async_system(cmd) abort "{{{ + let proc = vimproc#pgroup_open(a:cmd) + + " Close handles. + call proc.stdin.close() + + while !proc.stdout.eof + if !proc.stderr.eof + " Print error. + call neobundle#installer#error(proc.stderr.read_lines(-1, 100)) + endif + + call neobundle#util#redraw_echo(proc.stdout.read_lines(-1, 100)) + endwhile + + if !proc.stderr.eof + " Print error. + call neobundle#installer#error(proc.stderr.read_lines(-1, 100)) + endif + + call proc.waitpid() +endfunction"}}} + +let &cpo = s:save_cpo +unlet s:save_cpo diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/metadata.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/metadata.vim new file mode 100644 index 0000000..c93a89a --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/metadata.vim @@ -0,0 +1,84 @@ +"============================================================================= +" FILE: metadata.vim +" AUTHOR: Shougo Matsushita +" 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 + diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/parser.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/parser.vim new file mode 100644 index 0000000..1bcf6ff --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/parser.vim @@ -0,0 +1,314 @@ +"============================================================================= +" FILE: parser.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/sources/github.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/github.vim new file mode 100644 index 0000000..e89e33c --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/github.vim @@ -0,0 +1,119 @@ +"============================================================================= +" FILE: github.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/sources/metadata.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/metadata.vim new file mode 100644 index 0000000..3ce432c --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/metadata.vim @@ -0,0 +1,104 @@ +"============================================================================= +" FILE: metadata.vim +" AUTHOR: Shougo Matsushita +" 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 (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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/sources/vim_scripts_org.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/vim_scripts_org.vim new file mode 100644 index 0000000..d79f35f --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/sources/vim_scripts_org.vim @@ -0,0 +1,160 @@ +"============================================================================= +" FILE: vim_scripts_org.vim +" AUTHOR: Shougo Matsushita +" 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 (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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/types/git.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/types/git.vim new file mode 100644 index 0000000..ab30e42 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/types/git.vim @@ -0,0 +1,312 @@ +"============================================================================= +" FILE: git.vim +" AUTHOR: Shougo Matsushita +" Robert Nelson +" 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 =~# '\ +" 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 =~# '\ +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/types/raw.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/types/raw.vim new file mode 100644 index 0000000..ad771cc --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/types/raw.vim @@ -0,0 +1,116 @@ +"============================================================================= +" FILE: raw.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/types/svn.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/types/svn.vim new file mode 100644 index 0000000..336b6a3 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/types/svn.vim @@ -0,0 +1,93 @@ +"============================================================================= +" FILE: svn.vim +" AUTHOR: Shougo Matsushita +" 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 =~# '\ +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/neobundle/util.vim b/.vim/bundle/neobundle.vim/autoload/neobundle/util.vim new file mode 100644 index 0000000..8845b0f --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/neobundle/util.vim @@ -0,0 +1,510 @@ +"============================================================================= +" FILE: util.vim +" AUTHOR: Shougo Matsushita +" 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:is_windows = has('win32') +let s:is_cygwin = has('win32unix') +let s:is_mac = !s:is_windows && !s:is_cygwin + \ && (has('mac') || has('macunix') || has('gui_macvim') || + \ (!isdirectory('/proc') && executable('sw_vers'))) + +function! neobundle#util#substitute_path_separator(path) abort "{{{ + return (s:is_windows && a:path =~ '\\') ? + \ tr(a:path, '\', '/') : a:path +endfunction"}}} +function! neobundle#util#expand(path) abort "{{{ + let path = (a:path =~ '^\~') ? fnamemodify(a:path, ':p') : + \ (a:path =~ '^\$\h\w*') ? substitute(a:path, + \ '^\$\h\w*', '\=eval(submatch(0))', '') : + \ a:path + return (s:is_windows && path =~ '\\') ? + \ neobundle#util#substitute_path_separator(path) : path +endfunction"}}} +function! neobundle#util#join_paths(path1, path2) abort "{{{ + " Joins two paths together, handling the case where the second path + " is an absolute path. + if s:is_absolute(a:path2) + return a:path2 + endif + if a:path1 =~ (s:is_windows ? '[\\/]$' : '/$') || + \ a:path2 =~ (s:is_windows ? '^[\\/]' : '^/') + " the appropriate separator already exists + return a:path1 . a:path2 + else + " note: I'm assuming here that '/' is always valid as a directory + " separator on Windows. I know Windows has paths that start with \\?\ that + " diasble behavior like that, but I don't know how Vim deals with that. + return a:path1 . '/' . a:path2 + endif +endfunction "}}} +if s:is_windows + function! s:is_absolute(path) abort "{{{ + return a:path =~ '^[\\/]\|^\a:' + endfunction "}}} +else + function! s:is_absolute(path) abort "{{{ + return a:path =~ "^/" + endfunction "}}} +endif + +function! neobundle#util#is_windows() abort "{{{ + return s:is_windows +endfunction"}}} +function! neobundle#util#is_mac() abort "{{{ + return s:is_mac +endfunction"}}} +function! neobundle#util#is_cygwin() abort "{{{ + return s:is_cygwin +endfunction"}}} + +" Sudo check. +function! neobundle#util#is_sudo() abort "{{{ + return $SUDO_USER != '' && $USER !=# $SUDO_USER + \ && $HOME !=# expand('~'.$USER) + \ && $HOME ==# expand('~'.$SUDO_USER) +endfunction"}}} + +" Check vimproc. "{{{ +function! neobundle#util#has_vimproc() abort "{{{ + if !exists('*vimproc#version') + try + call vimproc#version() + catch + endtry + endif + + return exists('*vimproc#version') +endfunction"}}} +"}}} +" iconv() wrapper for safety. +function! s:iconv(expr, from, to) abort "{{{ + if a:from == '' || a:to == '' || a:from ==? a:to + return a:expr + endif + let result = iconv(a:expr, a:from, a:to) + return result != '' ? result : a:expr +endfunction"}}} +function! neobundle#util#system(str, ...) abort "{{{ + let command = a:str + let input = a:0 >= 1 ? a:1 : '' + let command = s:iconv(command, &encoding, 'char') + let input = s:iconv(input, &encoding, 'char') + + if a:0 == 0 + let output = neobundle#util#has_vimproc() ? + \ vimproc#system(command) : system(command, "\") + elseif a:0 == 1 + let output = neobundle#util#has_vimproc() ? + \ vimproc#system(command, input) : system(command, input) + else + " ignores 3rd argument unless you have vimproc. + let output = neobundle#util#has_vimproc() ? + \ vimproc#system(command, input, a:2) : system(command, input) + endif + + let output = s:iconv(output, 'char', &encoding) + + return substitute(output, '\n$', '', '') +endfunction"}}} +function! neobundle#util#get_last_status() abort "{{{ + return neobundle#util#has_vimproc() ? + \ vimproc#get_last_status() : v:shell_error +endfunction"}}} + +" Split a comma separated string to a list. +function! neobundle#util#split_rtp(runtimepath) abort "{{{ + if stridx(a:runtimepath, '\,') < 0 + return split(a:runtimepath, ',') + endif + + let split = split(a:runtimepath, '\\\@# a:b[1] ? 1 : -1'), 'v:val[0]') +endfunction"}}} + +" Executes a command and returns its output. +" This wraps Vim's `:redir`, and makes sure that the `verbose` settings have +" no influence. +function! neobundle#util#redir(cmd) abort "{{{ + let [save_verbose, save_verbosefile] = [&verbose, &verbosefile] + set verbose=0 verbosefile= + redir => res + silent! execute a:cmd + redir END + let [&verbose, &verbosefile] = [save_verbose, save_verbosefile] + return res +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! neobundle#util#print_bundles(bundles) abort "{{{ + echomsg string(map(copy(a:bundles), 'v:val.name')) +endfunction"}}} + +function! neobundle#util#sort_human(filenames) abort "{{{ + return sort(a:filenames, 's:compare_filename') +endfunction"}}} + +" Compare filename by human order. "{{{ +function! s:compare_filename(i1, i2) abort + let words_1 = s:get_words(a:i1) + let words_2 = s:get_words(a:i2) + let words_1_len = len(words_1) + let words_2_len = len(words_2) + + for i in range(0, min([words_1_len, words_2_len])-1) + if words_1[i] >? words_2[i] + return 1 + elseif words_1[i] a:width + let char = matchstr(ret, '.$') + let ret = ret[: -1 - len(char)] + let width -= s:wcswidth(char) + endwhile + + return ret +endfunction"}}} +function! s:strwidthpart_reverse(str, width) abort "{{{ + if a:width <= 0 + return '' + endif + let ret = a:str + let width = s:wcswidth(a:str) + while width > a:width + let char = matchstr(ret, '^.') + let ret = ret[len(char) :] + let width -= s:wcswidth(char) + endwhile + + return ret +endfunction"}}} +function! s:wcswidth(str) abort "{{{ + return v:version >= 704 ? strwidth(a:str) : strlen(a:str) +endfunction"}}} + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: foldmethod=marker + diff --git a/.vim/bundle/neobundle.vim/autoload/unite/kinds/neobundle.vim b/.vim/bundle/neobundle.vim/autoload/unite/kinds/neobundle.vim new file mode 100644 index 0000000..d79a0c9 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/kinds/neobundle.vim @@ -0,0 +1,106 @@ +"============================================================================= +" FILE: neobundle.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle.vim b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle.vim new file mode 100644 index 0000000..095fac8 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle.vim @@ -0,0 +1,143 @@ +"============================================================================= +" FILE: neobundle.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_install.vim b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_install.vim new file mode 100644 index 0000000..62038b0 --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_install.vim @@ -0,0 +1,190 @@ +"============================================================================= +" FILE: neobundle/install.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_lazy.vim b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_lazy.vim new file mode 100644 index 0000000..e965aaa --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_lazy.vim @@ -0,0 +1,76 @@ +"============================================================================= +" FILE: neobundle_lazy.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_log.vim b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_log.vim new file mode 100644 index 0000000..b43601f --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_log.vim @@ -0,0 +1,66 @@ +"============================================================================= +" FILE: neobundle/log.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_search.vim b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_search.vim new file mode 100644 index 0000000..655a4ba --- /dev/null +++ b/.vim/bundle/neobundle.vim/autoload/unite/sources/neobundle_search.vim @@ -0,0 +1,265 @@ +"============================================================================= +" FILE: neobundle_search.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/bin/install.sh b/.vim/bundle/neobundle.vim/bin/install.sh new file mode 100755 index 0000000..a34de5c --- /dev/null +++ b/.vim/bundle/neobundle.vim/bin/install.sh @@ -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!" diff --git a/.vim/bundle/neobundle.vim/bin/neoinstall b/.vim/bundle/neobundle.vim/bin/neoinstall new file mode 100755 index 0000000..914b3d9 --- /dev/null +++ b/.vim/bundle/neobundle.vim/bin/neoinstall @@ -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 '' diff --git a/.vim/bundle/neobundle.vim/bin/neoinstall.bat b/.vim/bundle/neobundle.vim/bin/neoinstall.bat new file mode 100644 index 0000000..77d4156 --- /dev/null +++ b/.vim/bundle/neobundle.vim/bin/neoinstall.bat @@ -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.' diff --git a/.vim/bundle/neobundle.vim/bin/neoinstall_novimproc.bat b/.vim/bundle/neobundle.vim/bin/neoinstall_novimproc.bat new file mode 100644 index 0000000..5dda690 --- /dev/null +++ b/.vim/bundle/neobundle.vim/bin/neoinstall_novimproc.bat @@ -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.' diff --git a/.vim/bundle/neobundle.vim/doc/neobundle.txt b/.vim/bundle/neobundle.vim/doc/neobundle.txt new file mode 100644 index 0000000..6ef803c --- /dev/null +++ b/.vim/bundle/neobundle.vim/doc/neobundle.txt @@ -0,0 +1,1753 @@ +*neobundle.txt* Next generation Vim package manager + +Version: 4.0 +Author: Shougo + 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. +}}} + +CONTENTS *neobundle-contents* + +Introduction |neobundle-introduction| +Usage |neobundle-usage| +Install |neobundle-install| +Interface |neobundle-interface| + Functions |neobundle-functions| + Commands |neobundle-commands| + Variables |neobundle-variables| + Options |neobundle-options| +Configuration Examples |neobundle-examples| +Migrating from Pathogen |neobundle-migrate-from-pathogen| +Unite sources |neobundle-unite-sources| +FAQ |neobundle-faq| + +============================================================================== +INTRODUCTION *neobundle-introduction* + +*neobundle* is the next generation Vim package manager. This plugin is based on +Vundle (https://github.com/gmarik/vundle), but I renamed and added tons of +features. Because, Vundle's author does not want to add huge features in +Vundle. + +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, ...) + +Neobundle features: + * Uses |vimproc| if available + * Uses neovim async jobs feature if available + * |unite.vim| interface + * Revision lock + * Supports svn/Mercurial repositories besides Git + * Can use a different base path + * Vundle like syntax + +============================================================================== +USAGE *neobundle-usage* + +Refer to the example: +|neobundle-examples| + +Run this command to update your bundled plugins: +> + :NeoBundleUpdate +< +Note: To use the unite.vim interface, run this command (requires |unite.vim|): +> + :Unite neobundle/update +< +Settings for this plugin are compatible with Vundle.vim :-) + +You can search popular plugins and add neobundle settings at Vimpusher +(registration required): + http://www.vimpusher.com/ +Or at vim-scripts.org: + http://vim-scripts.org/ + +Neobundle now features a plugin search for vim.org scripts (requires +|unite.vim|) +> + :Unite neobundle/search +< +============================================================================== +INSTALL *neobundle-install* + +Requirements: +* Vim 7.2.051 or above. +* "git" command in $PATH (if you want to install github or vim.org plugins) + +First of all, git clone the repository. + +Note: You need to have git installed. +> + $ mkdir ~/.vim/bundle + $ git clone https://github.com/Shougo/neobundle.vim ~/.vim/bundle/neobundle.vim +< +And set up a path to the repository directory. +> + set runtimepath+={path to neobundle directory} +< +Example: +> + set runtimepath+=~/.vim/bundle/neobundle.vim +< +Now configure your bundles. (Refer to |neobundle-examples|) + +Run the |:NeoBundleInstall| command to install your plugins. +> + $ vim +NeoBundleInstall +q + +or +> + $ . ~/.vim/bundle/neobundle.vim/bin/neoinstall +< +Note: To use neoinstall in Windows, Vim command must be in $PATH. > + > .vim/bundle/neobundle.vim/bin/neoinstall +Note: To update and build vimproc in Windows, you can use +"neoinstall_novimproc" command. > + > .vim/bundle/neobundle.vim/bin/neoinstall_novimproc vimproc.vim + +neoinstall can take arguments (install/update plugin names). +> + # Build vimproc before install plugins + $ . ~/.vim/bundle/neobundle.vim/bin/neoinstall vimproc.vim +< +============================================================================== +INTERFACE *neobundle-interface* + +------------------------------------------------------------------------------ +FUNCTIONS *neobundle-functions* + +neobundle#begin([{base-path}]) *neobundle#begin()* + Initializes neobundle.vim and start neobundle bundles + configuration block. + {base-path} is where your downloaded plugins will be placed. + + If {base-path} is omitted, neobundle looks for "~/.vim/bundle" + or "~/.config/nvim/bundle" directory. + Note: But recommend you to specify the {base-path}. + + Note: You must not call the function inside a + "has('vim_starting')" block. + Note: You can use |neobundle#begin()| / |neobundle#end()| block + only once in your .vimrc. + + Note: It executes ":filetype off" automatically. + Note: You must execute |:NeoBundle| commands in + |neobundle#begin()| or |neobundle#append()| block. +> + if &compatible + set nocompatible + endif + set runtimepath+={path to neobundle directory} + + call neobundle#begin(expand('~/.vim/bundle')) + + NeoBundle 'https://github.com/Shougo/neocomplcache.git' + ... + + call neobundle#end() + + filetype plugin indent on +< + +neobundle#append() *neobundle#append()* + Start neobundle bundles configuration block. + You can use multiple |neobundle#append()| / |neobundle#end()| + blocks in your .vimrc. + Note: It does not initialize neobundle. You must call + |neobundle#begin()| at first. + Note: It executes ":filetype off" automatically. + Note: You must execute |:NeoBundle| commands in + |neobundle#begin()| or |neobundle#append()| block. + +neobundle#end() *neobundle#end()* + End neobundle bundles configuration block. + +neobundle#add({repository}[, {options}]) *neobundle#add()* + The function version of |:NeoBundle|. + Note: You must call it in |neobundle#begin()| or + |neobundle#append()| block. + +neobundle#add_meta({repository}[, {options}]) *neobundle#add_meta()* + Initialize a bundle from the metadata {name}. + Note: You must call it in |neobundle#begin()| or + |neobundle#append()| block. > + + " It installs vimshell and vimproc + call neobundle#add_meta('vimshell') + +neobundle#source({bundle-names}) *neobundle#source()* + Same as |:NeoBundleSource|. + {bundle-names} is a list of bundle names. + + *neobundle#exists_not_installed_bundles()* +neobundle#exists_not_installed_bundles() + Checks if there are any bundles that are not installed. + + *neobundle#get_not_installed_bundle_names()* +neobundle#get_not_installed_bundle_names() + Returns the names of bundles that are not installed. + + *neobundle#is_installed()* +neobundle#is_installed({bundle-name}) + Checks if bundle {bundle-name} is installed. + + *neobundle#is_sourced()* +neobundle#is_sourced({bundle-name}) + Checks if bundle {bundle-name} is loaded. + + *neobundle#local()* +neobundle#local({directory}, [{options}, [{names}]]) + Adds the subdirectories in {directory} to + 'runtimepath', like |pathogen| does. See |neobundle-options| + for keys to set in {options}. + If {names} is given, {names} directories are only loaded. + {names} is |wildcards| list. + Note: |:NeoBundleLocal| is a shortcut for this function. +> + " Load plugin from "~/.vim/bundle". + call neobundle#local("~/.vim/bundle", {}) + " Load plugin1 and plugin2 from "~/.vim/bundle". + call neobundle#local("~/.vim/bundle", + \ {}, ['plugin1', 'plugin2', 'vim-*', '*.vim']) +< + *neobundle#load_toml()* +neobundle#load_toml({filename}, [{options}]) + Load TOML plugin configurations from {filename}. See + |neobundle-options| for keys to set in {options}. + Note: TOML parser is slow. You should use neobundle cache + feature. + + TOML file format specification: + https://github.com/toml-lang/toml + Note: Original TOML parser is created by kamichidu. + https://github.com/kamichidu +> + " Load toml from "~/.vim/bundle.toml". + call neobundle#load_toml("~/.vim/bundle.toml", {}) +< + TOML file sample is here: +> + # TOML sample + [[plugins]] + # repository name is required. + repo = 'kana/vim-niceblock' + on_map = '' + + [[plugins]] + repo = 'Shougo/neosnippet.vim' + depends = ['Shougo/neosnippet-snippets', + 'Shougo/context_filetype.vim'] + on_i = 1 + on_ft = 'snippet' + + [[plugins.depends]] + repo = 'honza/vim-snippet' + name = 'honza-snippet' + + [[plugins]] + repo = 'Shougo/neobundle.vim' + fetch = 1 + + [[plugins]] + repo = 'Shougo/vimproc.vim' + + [plugins.build] + windows = 'tools\\update-dll-mingw' + cygwin = 'make -f make_cygwin.mak' + mac = 'make -f make_mac.mak' + unix = 'make -f make_unix.mak' +< +neobundle#get({bundle-name}) *neobundle#get()* + Get the neobundle options dictionary for {bundle-name}. + Useful for setting hooks. + Example: +> + NeoBundle 'tyru/open-browser.vim', '', 'same', { + \ 'on_map' : '', + \ } + nmap gs (open-browser-wwwsearch) + + let bundle = neobundle#get('open-browser.vim') + function! bundle.hooks.on_source(bundle) + nnoremap (open-browser-wwwsearch) + \ :call www_search() + function! s:www_search() + let search_word = input('Please input search word: ', '', + \ 'customlist,wwwsearch#cmd_Wwwsearch_complete') + if search_word != '' + execute 'OpenBrowserSearch' escape(search_word, '"') + endif + endfunction + endfunction +< +neobundle#get_hooks({bundle-name}) *neobundle#get_hooks()* + Get the neobundle "hooks" dictionary for {bundle-name}. + Useful for setting hooks. + +neobundle#call_hook({hook-name}) *neobundle#call_hook()* + Calls the hook {hook-name}. + Note: If {hook-name} is "on_source", neobundle will call + "on_source" hooks in sourced bundles. + +neobundle#bundle({repository}, [{options}]) *neobundle#bundle()* + Initialize a bundle. + If {repository} is list, you can initialize options in + multiple bundles. + Note: You can use this function instead of |:NeoBundle| + command. + +neobundle#config({bundle-name}, {options}) *neobundle#config()* +neobundle#config({options}) + Change bundle options for {bundle-name}. + It you omit {bundle-name}, it uses |neobundle#tapped| + variable. + If {bundle-name} is list, you can change options in multiple + bundles. + If {bundle-name} is not configured, it will print error + messages. + If {bundle-name} is already loaded, it will ignore. + + Note: To lazy-load a plugin, you can set the "lazy" flag after + calling |:NeoBundle| or |:NeoBundleLocal|. + Note: You must call it within + |neobundle#begin()|/|neobundle#end()| block. +> + NeoBundle 'Shougo/neocomplcache' + call neobundle#config('neocomplcache', { + \ 'lazy' : 1, + \ 'on_i' : 1, + \ }) +< +neobundle#tap({bundle-name}) *neobundle#tap()* + Initialize |neobundle#tapped| and |neobundle#hooks| variable + as {bundle-name} bundle. + It returns non-zero if {bundle-name} is exists and not + disabled. +> + if neobundle#tap('foo') + " If foo plugin is installed and enabled + + " neobundle#hooks is syntax sugar + function! neobundle#hooks.on_source(bundle) + " Settings, Init, ... + " Timing of adding rtp + " Like vimrc time + let g:foo#bar = 1 + let g:foo#path = a:bundle.path + call foo#baz() + endfunction + + function! neobundle#hooks.on_post_source(bundle) + " Settings, Init, ... + " Timing of after source plugin files + " Like VimEnter time + let g:foo#bar = 3 + call foo#bazbaz() + endfunction + + " Define plugin mappings, commands, ... + map f (foo) + command! FOO call foo#foo() + + call neobundle#untap() + endif +< +neobundle#untap() *neobundle#untap()* + Clear current |neobundle#tapped| and |neobundle#hooks| variable. + +neobundle#has_cache() *neobundle#has_cache()* + Checks if a cache file is available. + Note: It is deprecated. You should use + |neobundle#load_cache()| instead of it. + +neobundle#load_cache([{vimrcs}]) *neobundle#load_cache()* + Load plugin configuration from the cache file, + which is located in `neobundle#get_rtp_dir() . '/cache'`. + {vimrcs} is a list of compared .vimrc and/or other configuration + files. The default is |$MYVIMRC|. + + It returns 1, if the cache file is old or invalid or not + found. + + The default cache location can be overridden through + |g:neobundle#cache_file|. +> + if neobundle#load_cache() + " My Bundles here: + " ... + NeoBundleSaveCache + endif +< + If you use multiple configuration files, +> + if neobundle#load_cache($MYVIMRC, 'plugin.vim', 'plugin.toml') + " My Bundles here or other files spcified as arguments + " ... + NeoBundleSaveCache + endif +< +------------------------------------------------------------------------------ +COMMANDS *neobundle-commands* + + *:NeoBundle* +:NeoBundle {repository} [[,{revision}] [,{options}]] +:NeoBundle {repository} ,{revision}, {default} [,{options}]] + Initialize a bundle. + {repository} is the repository URI. {revision} is the desired + revision or branch name. If omitted, the current latest + revision will be used. {default} is a "default options + name" (See |g:neobundle#default_options|). + Note: Don't set neobundle setting in .gvimrc! + Note: If you omit the protocol (ex: https) for a git + repo, |g:neobundle#types#git#default_protocol| is used. + Note: |neobundle-options-lazy| is set automatically. + + Note: If you manage bundle by neobundle, it may be error + occurred when update bundles. + + See |neobundle-options| for what to set in {options}. + +:NeoBundleInstall [{name}...] *:NeoBundleInstall* + Installs plugins specified by {name}. {name} is + fuzzy-searched. If {name} is omitted, all configured plugins + are installed. + Note: {name}s are plugin names like "neobundle.vim", not + "Shougo/neobundle.vim". + Note: neobundle cannot use neovim async jobs feature in the + command. If you want to use the feature, you should use unite + interface instead. + +:NeoBundleInstall! [{name}...] *:NeoBundleInstall!* + Same as |:NeoBundleUpdate|. + +:NeoBundleUpdate [{name}...] *:NeoBundleUpdate* + Installs and updates plugins specified by {name}. {name} is + fuzzy-searched. If {name} is omitted, all configured plugins + are installed and updated, except if they are outdated or have + the "frozen" option set. + Note: {name}s are plugin names like "neobundle.vim", not + "Shougo/neobundle.vim". + Note: neobundle cannot use neovim async jobs feature in the + command. If you want to use the feature, you should use unite + interface instead. + +:NeoBundleUpdate! [{name}...] *:NeoBundleUpdate!* + Same as |:NeoBundleUpdate|, except that it disregards the + "frozen" option. + +:NeoBundleReinstall [{name}...] *:NeoBundleReinstall* + Reinstalls the bundles specified by {name}. + If the bundles are "none" type or local plugins, they are + ignored. + Note: It removes the bundles and installs them. It is the + dangerous command. + +:NeoBundleList *:NeoBundleList* + Prints a list of configured bundles. + +:NeoBundleLog *:NeoBundleLog* + Prints all previous install logs. + +:NeoBundleUpdatesLog *:NeoBundleUpdatesLog* + Prints previous update logs. + +:NeoBundleLocal {base-directory-path} *:NeoBundleLocal* + Registers a bundle from the directories in + {base-directory-path} like pathogen does. + + Note: If you want to use neobundle like pathogen.vim, you + should set a different base path from the standard neobundle + bundles path. +> + NeoBundleLocal ~/.vim/bundle +< + *:NeoBundleLazy* +:NeoBundleLazy {repository} [[,{revision}] [,{options}]] +:NeoBundleLazy {repository} ,{revision}, {default} [,{options}]] + Registers a bundle, but doesn't add it to 'runtimepath'. + Note: If you want to know slow loading plugins, you should use + the external tool or |--startuptime|. + https://github.com/hyiltiz/vim-plugins-profile +> + NeoBundleLazy 'The-NERD-tree', {'augroup' : 'NERDTree'} + NeoBundleSource The-NERD-tree +< + You can use it to load plugins for specific filetypes. +> + NeoBundleLazy 'Rip-Rip/clang_complete' + autocmd FileType c,cpp NeoBundleSource clang_complete +< +:NeoBundleSource [{name}...] *:NeoBundleSource* + |:source| the bundles specified by {name}. + If {name} is omitted, |:source| all lazy bundles. + Note: This command is used to load the bundles configured with + |:NeoBundleLazy|. + +:NeoBundleFetch {repository} [, {options}] *:NeoBundleFetch* + Registers a bundle, but doesn't add it to 'runtimepath'. + Unlike |:NeoBundleLazy|, you cannot load the bundle with + |:NeoBundleSource|. This command is useful for managing + non-Vim plugins using neobundle. +> + NeoBundleFetch 'davidhalter/jedi' +< +:NeoBundleDocs *:NeoBundleDocs* + Execute |:helptags| for all bundles manually. + + *:NeoBundleDirectInstall* +:NeoBundleDirectInstall {repository} [, {options}] + Registers a bundle, and installs it directly. + Note: The settings are saved in "extra_bundles.vim" in + |neobundle#begin()| directory. + Note: To remove direct installed bundles, you must delete + plugin settings manually in "extra_bundles.vim" in + |neobundle#begin()| directory. +> + NeoBundleDirectInstall 'Shougo/neocomplcache' +< + *:NeoBundleExtraEdit* +:NeoBundleExtraEdit + Edit extra bundles configuration easily. + +:NeoBundleDisable {name}... *:NeoBundleDisable* + Disables bundles specified by {name}. If a bundle is + disabled, its path will be removed from 'runtimepath'. + Note: This command must be executed before neobundle loads + the plugins(after |neobundle#end()|). + +:NeoBundleCheck *:NeoBundleCheck* + Check plugins installation. If plugins are not installed, it + will execute |:NeoBundleInstall| automatically. This command + also check documentation directories and will execute + |:NeoBundleDocs| automatically. + +:NeoBundleCheckUpdate [{name}...] *:NeoBundleCheckUpdate* + Check plugins update specified by {name}. If updates are + available, it will execute |:NeoBundleUpdate| automatically. + Note: It is supported in git type only. + + *:NeoBundleCount* +:NeoBundleCount + Show bundles count. You can know how many bundles you have. + + *:NeoBundleGC* +:NeoBundleGC [{bundle-names}] + Execute Garbage Collect commands in bundles. + If {bundle-name} is omit, all bundles will be GCed. + + *:NeoBundleSaveCache* +:NeoBundleSaveCache + Save plugin configuration in the cache file. + Note: It cannot save functions for example "hooks" member. + Note: It is available when loading .vimrc. + + *:NeoBundleLoadCache* +:NeoBundleLoadCache + Load plugin configuration from the cache file, + which is located in `neobundle#get_rtp_dir() . '/cache'`. + + Note: It is deprecated. You should use + |neobundle#load_cache()| instead of it. + + *:NeoBundleClearCache* +:NeoBundleClearCache + Clear the configuration cache file. + + *:NeoBundleRollback* +:NeoBundleRollback {bundle-name} + Rollback {bundle-name} plugin version to previous updated + version. + Note: If you rollbacked the plugin, you cannot update it by + |:NeoBundleUpdate| command. If you want to update it, you + must reinstall the plugin by |:NeoBundleReinstall| command. + + *:NeoBundleRemotePlugins* +:NeoBundleRemotePlugins + Load not loaded neovim |:remote-plugin| and execute + |:UpdateRemotePlugins| command. + It is better than |:UpdateRemotePlugins| for neobundle + autoloading feature. + Note: It is valid in neovim. + +------------------------------------------------------------------------------ +VARIABLES *neobundle-variables* + +g:neobundle#cache_file *g:neobundle#cache_file* + The cache file to use. + + The default is provided through + neobundle#commands#get_default_cache_file(): +> + neobundle#get_rtp_dir() . '/cache' +< +neobundle#tapped *neobundle#tapped* + Current bundle variable set by |neobundle#tap()|. + +neobundle#hooks *neobundle#hooks* + Current bundle hooks variable set by |neobundle#tap()|. + +g:neobundle#default_site *g:neobundle#default_site* + The default repository site if "site" option is omitted. + + Defaults to "github". + +g:neobundle#log_filename *g:neobundle#log_filename* + The log filename. Set it to "" to disable logging. + + Defaults to "". + + *g:neobundle#enable_name_conversion* +g:neobundle#enable_name_conversion + If you set to 1 and omit bundle name, + |neobundle-options-normalized_name| is used as bundle name. + It is useful for absorbing difference of repository name. + +g:neobundle#rm_command *g:neobundle#rm_command* + The command used to remove files to uninstall. + + Defaults to "rmdir /S /Q" on Windows or "rm -rf" in + others. + + *g:neobundle#install_max_processes* +g:neobundle#install_max_processes + The max number of processes used for neobundle/install source + asynchronous update. + + Defaults to "8". + + *g:neobundle#install_process_timeout* +g:neobundle#install_process_timeout + The time of timeout seconds when updating/installing bundles. + + Defaults to "120". + +g:neobundle#default_options *g:neobundle#default_options* + A dictionary of preconfigured sets of options to use when + options are omitted for individual commands or functions. + Keys are arbitrary names for the option sets, and values are + dictionaries themselves that store option keys and values. + Use the special key "_" to store a "default default options". + Example: +> + let g:neobundle#default_options = + \ { 'rev' : {'rev' : 'ver.8'} } + NeoBundle 'Shougo/neocomplcache', '', 'rev' +< + Defaults to "{}". + + *g:neobundle#types#raw#calc_hash_command* +g:neobundle#types#raw#calc_hash_command + The hash command to use in raw repositories. + + Defaults to "sha1sum" or "md5sum". + + *g:neobundle#types#git#command_path* +g:neobundle#types#git#command_path + The "git" command path used for git type. + + Defaults to "git". + + *g:neobundle#types#git#default_protocol* +g:neobundle#types#git#default_protocol + The default protocol used for git (github). + Note: It is accepted in "https" or "ssh". + + Defaults to "https". + + *g:neobundle#types#git#enable_submodule* +g:neobundle#types#git#enable_submodule + If it is non-zero, neobundle enables git submodule support. + But it may be slow in Windows environment. + + Defaults to 1. + + *g:neobundle#types#git#clone_depth* +g:neobundle#types#git#clone_depth + The default history depth for "git clone". + If it is 1, neobundle use shallow clone feature. + See |neobundle-options-type__depth|. + + Defaults to 0. + + *g:neobundle#types#git#pull_command* +g:neobundle#types#git#pull_command + The git command used to pull updates. + The previous default has been "pull --rebase". + + Defaults to "pull --ff --ff-only". + + *g:neobundle#types#hg#command_path* +g:neobundle#types#hg#command_path + The "hg" command path used for hg type. + + Defaults to "hg". + + *g:neobundle#types#hg#default_protocol* +g:neobundle#types#hg#default_protocol + The default protocol used for hg (bitbucket). + Note: It is accepted in "https" or "ssh". + + Defaults to "https". + + *g:neobundle#types#svn#command_path* +g:neobundle#types#svn#command_path + The "svn" command path used for svn type. + + Defaults to "svn". + +------------------------------------------------------------------------------ +OPTIONS *neobundle-options* + The {options} in neobundle commands accept the following keys: + + *neobundle-options-name* + name (String) + Specify the name of the bundle. This is used for neobundle + management and other commands (like |:NeoBundleUpdate|). If + omitted, the tail of the repository name will be used. + Note: Must be unique across all bundles. If a bundle name + conflicts with another bundle, neobundle will overwrite the + previous settings with the new one. If a repo tail is bound to + conflict, you can set the "name" option manually to prevent + overwriting an existing bundle setting. + Example: +> + NeoBundle 'https://github.com/Shougo/unite.vim.git', + \ {'name' : 'unite'} + NeoBundle 'https://github.com/foo/foo.git', + \ {'name' : 'foo-foo'} + NeoBundle 'https://github.com/bar/foo.git', + \ {'name' : 'bar-foo'} + NeoBundle 'https://git.code.sf.net/p/atp-vim/code', + \ {'name': 'atp-vim'} +< + *neobundle-options-normalized_name* + normalized_name (String) + Specify the normalized name of the bundle. This is used for + neobundle management to detect dependencies. If omitted, + neobundle will normalize the tail of the repository name. + Note: Must be unique across all bundles. + Normalized name example: + name : normalized name +> + unite.vim unite + vim-quickrun quickrun +< + description (String) + Plugin description. + + rev (String) + Specify a revision number or branch/tag name. + If it is "release" in "git" type, neobundle will use latest + released tag. + Note: If the type is "raw", rev is hash number. + + Example: +> + NeoBundle 'Shougo/vimshell', { 'rev' : '3787e5' } +< + *neobundle-options-default* + default (String) + Specify a default option name. (See |g:neobundle#default_options|). + + *neobundle-options-directory* + directory (String) + Specify relative directory path from the base directory (set + by |neobundle#begin()| or "base" option). If omitted, the "name" + option will be used. + Note: If you set rev "foo" when the name key is "neobundle", + the directory key is "neobundle_foo". + + Example: +> + NeoBundle 'https://github.com/Shougo/unite.vim.git', + \ {'directory' : 'unite'} +< + *neobundle-options-base* + base (String) + Directory base path to use. If omitted, the path specified + with |neobundle#begin()| will be used. It is useful for + loading scripts from a different path. + + *neobundle-options-type* + type (String) + Specify the repository type. If omitted, a guess is made + based on {repository}. + + Available types: + "none" : None repository + "raw" : Raw plugin file ("script_type" attribute is + needed) + "git" : Git + "hg" : Mercurial + "svn" : Subversion + "vba" : Vimball + + Example: +> + NeoBundle 'https://host/path/repo.git', {'type': 'hg'} + NeoBundle 'thinca/vim-localrc', {'type' : 'svn'} +< + *neobundle-options-script_type* + script_type (String) + Specify the script type. It is useful for non-official + categorized plugins. + For example: "indent", "plugin", "ftplugin", ... + Note: You must not specify it for categorized plugins. + Example: +> + NeoBundle 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim', + \ {'script_type' : 'plugin'} + NeoBundle 'https://github.com/bronzehedwick/impactjs-colorscheme', + \ {'script_type' : 'colorscheme'} +< + *neobundle-options-site* + site (String) + Specify the repository site. If you omit both the repository + URL and the "site" option, |g:neobundle#default_site| will be + used. + Note: You can specify site by "{site-name}:{path}". + For example: "github:Shougo/vimshell" + + Available sites: + "github" or "gh" : github.com (git) + "bitbucket" or "bb" : bitbucket.org (hg) + "gist" : gist.github.com (git) + + *neobundle-options-rtp* + rtp (String) + Specify runtime path. + Use this option when the repository has the Vim plugin + in a subdirectory. + For example: https://github.com/rstacruz/sparkup + + Example: +> + NeoBundle 'rstacruz/sparkup', {'rtp': 'vim'} + NeoBundle 'https://code.google.com/p/vimwiki/', { + \ 'rtp': "~/.vim/bundle/vimwiki/src", + \ } +< + *neobundle-options-depends* + depends (List or String) + Specify a list of plugins a plugin depends on. + List items are '{plugin-name}' or ['{plugin-name}', {args}]. + Those specified in the list are installed automatically. If + the {plugin-name} needs options, specify them with {args}. + Note: Type String is syntax sugar for List of {plugin-name}. + + Example: +> + NeoBundle 'Shougo/vimfiler', {'depends' : 'Shougo/unite.vim' } + NeoBundle 'Shougo/neocomplcache', {'depends' : + \ [ 'Shougo/neosnippet.git', + \ ['rstacruz/sparkup', {'rtp': 'vim'}], + \ ]} +< + *neobundle-options-build* + build (Dictionary or String) + Specify the build script. + You may use this option if the plugin has to be built before + use. If the build script requires external commands, see + |neobundle-options-build_commands|. + This command is executed by |system()| or |vimproc#system()| + in plugin runtimepath. + Note: Type String is syntax sugar for Dictionary of + {"others": "cmd"}. + + This dictionary accepts the following keys: + + windows (String) + Specify Windows environment build script. + + mac (String) + Specify Mac OS X environment build script. + + cygwin (String) + Specify Cygwin environment build script. + + linux (String) + Specify Linux environment build script. + Note: It is detected if "gmake" command is not + executable. + + unix (String) + Specify Unix environment build script. + + others (String) + Specify others environment build script. + If you don't specify other keys, it means "all". + + Example: +> + NeoBundle 'Shougo/vimproc.vim', { + \ 'build' : { + \ 'windows' : 'tools\\update-dll-mingw', + \ 'cygwin' : 'make -f make_cygwin.mak', + \ 'mac' : 'make -f make_mac.mak', + \ 'linux' : 'make', + \ 'unix' : 'gmake', + \ }, + \ } +< + Note: The command is executed in plugin top directory. + If you need cd command, you must use "sh -c". > + NeoBundle 'wincent/command-t', { + \ 'build': { + \ 'others' : + \ 'sh -c "cd ruby/command-t && ruby extconf.rb && make"' + \ } + \ } +< + *neobundle-options-augroup* + augroup (String) + Specify an augroup name that the plugin uses for |VimEnter| or + |GUIEnter| autocmd events. + Neobundle will call their |VimEnter| or |GUIEnter| autocmds + automatically when |:NeoBundleSource| is executed. + Note: You'll want to set this option because some plugins + rely on autocmds defined for |VimEnter| or |GUIEnter|, but by + using |:NeoBundleSource| after loading .vimrc, those autocmds + may get skipped. Some examples are, "fugitive", "NERDTree", + and "session.vim". + + Examples: +> + " NERDTree uses augroup NERDTreeHijackNetrw. + NeoBundle 'scrooloose/nerdtree', { 'augroup' : 'NERDTreeHijackNetrw'} + " fugitive uses augroup fugitive. + NeoBundle 'tpope/vim-fugitive', { 'augroup' : 'fugitive'} +< + This option is also valid in |:NeoBundleLazy|. + + *neobundle-options-external_commands* + external_commands (Dictionary or List or String) + Specify a list of external commands that the plugin depends + on. List items are '{command-name}' or ['{command-name}', + ...] or { {dictionary} }. + The commands are checked when loading the plugin. + Note: Type String is syntax sugar for list of {command-name}s. + + The {dictionary} has following keys: + + windows (String) + Specify Windows environment external commands. + + mac (String) + Specify Mac OS X environment external commands. + + cygwin (String) + Specify Cygwin environment external commands. + + unix (String) + Specify Unix environment external commands. + + others (String) + Specify others environment external commands. + + Example: +> + NeoBundle 'ujihisa/neco-ghc', { 'external_commands' : 'ghc-mod' } +< + *neobundle-options-build_commands* + build_commands (Dictionary or List or String) + Specify a list of external commands that are required for + building the plugin. If any of these commands are not + installed, the bundle will not be built. The list is the same + format as |neobundle-options-external_commands|. + + Example: +> + NeoBundle 'Valloric/YouCompleteMe', { 'build_commands' : 'cmake' } +< + + *neobundle-options-frozen* + frozen (Number) + If set to 1, neobundle doesn't update it automatically when + |:NeoBundleUpdate| or ":Unite neobundle/update" is called with + no arguments. It is useful for outdated plugins that can no + longer be updated. +> + NeoBundle 'Shougo/neobundle', { 'frozen' : 1 } +< + *neobundle-options-lazy* + lazy (Number) + If set to 1, neobundle doesn't add the path to user + runtimepath. + + *neobundle-options-fetch* + fetch (Number) + If set to 1, neobundle doesn't add the path to user + runtimepath, and doesn't load the bundle. + + *neobundle-options-force* + force (Number) + If set to 1, neobundle will load plugin files in the plugin + repository forcedly. + Note: It is useful for using Bundle within bundle. + https://github.com/Shougo/neobundle.vim/issues/199 + + *neobundle-options-gui* + gui (Number) + If set 1, neobundle will only load the plugin in GUI Vim. + + Example: > + NeoBundle 'tyru/restart.vim', '', 'same', { + \ 'gui' : 1, + \ 'on_cmd' : 'Restart' + \ } +< + *neobundle-options-terminal* + terminal (Number) + If set to 1, neobundle will only load the plugin in Terminal + Vim. + + *neobundle-options-vim_version* + vim_version (String) + Minimal vim version of the plugin supported. + It accepts some version formats such as "7" and "7.3" and + "7.3.885". + + *neobundle-options-disabled* + disabled (Number) or (String) + If set to 1, neobundle will disable the plugin. + If it is string, neobundle will eval the string. + Note: Disabled plugins are not ignored when install/update + plugins. + + Example: > + " neocomplete requires Vim 7.3.885 or above. + NeoBundle 'Shougo/neocomplete', { + \ 'depends' : 'Shougo/context_filetype.vim', + \ 'disabled' : !has('lua'), + \ 'vim_version' : '7.3.885' + \ } +< + *neobundle-options-focus* + focus (Number) + If it is > 0, neobundle will source the plugin when focus + is lost. It also is source priority. + http://d.hatena.ne.jp/osyo-manga/20140212/1392216949 + Example: > + " Source all plugins when focus is lost. + let g:neobundle#default_options._ = { 'verbose' : 1, 'focus' : 1 } +< + *neobundle-options-verbose* + verbose (Number) + If set to 1, neobundle will print message when it is sourced. + + *neobundle-options-install_process_timeout* + install_process_timeout (Number) + The time of timeout seconds when updating/installing bundles. + If omit it, |g:neobundle#install_process_timeout| will be used. + Note: This feature is available if you installed |vimproc|. + + *neobundle-options-autoload* + autoload (Dictionary) + Specify autoload conditions. + If you set it, neobundle will execute |:NeoBundleSource| + automatically when the conditions are met. + Note: This dictionary is deprecated. + + *neobundle-options-on_ft* + on_ft (List) or (String) + Filetype list. If the filetype is "all", it means all + filetypes. + Note: Using this will usually cause Neobundle to + either reset the ftplugin state, or explicitly call + the FileType autocommand another time (after adding + the lazy-loaded bundle), which results in the + autocommand to be processed twice for all other + plugins. Therefore, using "all" does not make sense + usually. + + *neobundle-options-filetypes* + It is deprecated key. + + *neobundle-options-on_cmd* + on_cmd (List) or (String) + Command list. The item can be following dictionary. + name (String) or (List) + Command name or the list of command names. + + Example: > + NeoBundle 'Shougo/vimfiler.vim', { + \ 'depends' : 'Shougo/unite.vim', + \ 'on_cmd' : ['VimFiler', 'VimFilerEdit', + \ 'VimFilerWrite','VimFilerRead', + \ 'VimFilerSource'], + \ 'on_map' : '', + \ 'on_path' : '.*', + \ } +< + *neobundle-options-commands* + It is deprecated key. + + *neobundle-options-on_func* + on_func (List) or (String) + Functions list. + + *neobundle-options-functions* + It is deprecated key. + + *neobundle-options-on_map* + on_map (List) or (String) + Mappings list. The items are {mapping} or + [{mode}, {mapping1}, [{mapping2}, ...]]. If {mode} is + omitted, "nxo" is used. + Note: You can use plugin prefix mappings. + For example, you can use "(ref-" instead of + "(ref-back)" and so on. + + Note: You can use "" keyword as {mapping}. If + {mapping} is "", "(normalized_name" is + used. + For example: > + " It is same as "'mappings' : '(anzu' + NeoBundle 'osyo-manga/vim-anzu', { + \'on_map': ''} +< + Note: You cannot use lazy mappings twice. + For example: > + NeoBundle 'osyo-manga/vim-anzu', { + \ 'on_map': '(anzu-'} + " Not working!! + nmap n (anzu-jump-n)(anzu-echo-search-status)zv + nmap N (anzu-jump-N)(anzu-echo-search-status)zv +< + *neobundle-options-mappings* + It is deprecated key. + + *neobundle-options-on_i* + on_i (Number) + If set to non-zero, neobundle will |:NeoBundleSource| + on |InsertEnter| autocmd. + + *neobundle-options-insert* + It is deprecated key. + + *neobundle-options-on_path* + on_path (String) or (List) + If set to ".*", neobundle will |:NeoBundleSource| + on editing all files. + Otherwise, neobundle will |:NeoBundleSource| if the + buffer name is matched the string pattern. + Note: It is useful for explorer behavior plugins. + Ex: vimfiler, metarw, vim-gnupg ... + Note: To autoload vimfiler, you must disable netrw in + .vimrc. > + " Disable netrw.vim + let g:loaded_netrwPlugin = 1 +< + For example: > + NeoBundle 'kana/vim-meta', { + \ 'on_path' : '\h\w*:', + \ } +< + *neobundle-options-explorer* + *neobundle-options-filename_patterns* + It is deprecated key. + + *neobundle-options-on_source* + on_source (List) or (String) + Load the bundle when the list bundles are loaded. + Note: If they are not autoload bundles, "on_source" + hooks are called when |VimEnter| auto command. + You can call them manually by |neobundle#call_hook()|. + Note: The plugins must be lazy loaded plugins. + + For example: > + if neobundle#tap('plugin-B.vim') + call neobundle#config({ + \ 'on_source' : [ 'plugin-A.vim' ] + \ }) + call neobundle#untap() + endif +< + plugin-B is loaded before plugin-A is loaded. + + *neobundle-options-pre_cmd* + pre_cmd (List) or (String) + Autoload command prefix in commands. + If the prefix is set, commands were loaded + automatically. + If omitted it, automatically generated prefix is used. + Example: If you use "unite.vim", "Unite" command + prefix is used. + Note: It requires Vim 7.4.414 or above. + + *neobundle-options-command_prefix* + It is deprecated key. + + Autoload examples: +> + NeoBundle 'Rip-Rip/clang_complete', { + \ 'on_ft' : ['c', 'cpp'], + \ } + NeoBundle 'basyura/TweetVim', { 'depends' : + \ ['basyura/twibill.vim', 'tyru/open-browser.vim'], + \ 'on_cmd' : 'TweetVimHomeTimeline' } + NeoBundle 'kana/vim-smartword', { + \ 'on_map' : [ + \ '(smartword-''] + \ } + NeoBundle 'Shougo/vimshell',{ + \ 'depends' : 'Shougo/vimproc.vim', + \ 'on_cmd' : [{ 'name' : 'VimShell', + \ 'complete' : 'customlist,vimshell#complete'}, + \ 'VimShellExecute', 'VimShellInteractive', + \ 'VimShellTerminal', 'VimShellPop'], + \ 'on_map' : '' + \ }) + NeoBundle 'Shougo/vimfiler', { + \ 'depends' : 'Shougo/unite.vim', + \ 'on_cmd' : [{ 'name' : 'VimFiler', + \ 'complete' : 'customlist,vimfiler#complete' }, + \ 'VimFilerExplorer', + \ 'Edit', 'Read', 'Source', 'Write'], + \ 'on_map' : '', + \ 'on_path' : '.*', + \ } + NeoBundle 'Shougo/junkfile.vim', { + \ 'on_cmd' : 'JunkfileOpen', + \ } + NeoBundle 'tyru/winmove.vim', { + \ 'on_map' : [ + \ ['n', '']], + \ 'gui' : 1, + \ 'augroup' : 'winmove', + \ } + NeoBundle 'sophacles/vim-processing', { + \'on_path': '\.pde$' + \} + NeoBundle 'LeafCage/cmdlineplus.vim', { + \ 'on_map': [['c', '']]} +< + *neobundle-options-hooks* + hooks (Dictionary) + Specify hook functions or hook script path. The following + hooks are defined: + + *neobundle-hooks-on_source* + on_source + Called or sourced before scripts are sourced. It is + useful for plugin initialization in lazy bundles. + Note: You must call the hook before |neobundle#end()|. + + *neobundle-hooks-on_post_source* + on_post_source + Called or sourced after scripts are sourced. + Note: In Vim initializing, calling the hooks are + delayed until |VimEnter|. + Note: To re-call on_source hook when reloading .vimrc, + you must call the hook in end of .vimrc. + + *neobundle-options-type__protocol* + type__protocol (String) + The protocol used for types. + "https" and "ssh" are available for git type. + "https" is available for hg type. + If omitted, |g:neobundle#types#git#default_protocol| + or |g:neobundle#types#hg#default_protocol| is used. + Note: This attribute is available in git and hg types only. + + Examples: +> + NeoBundle 'ujihisa/neco-ghc', { 'type__protocol' : 'ssh' } +< + *neobundle-options-type__filename* + type__filename (String) + The downloaded filename. + If omitted, URI filename will be used. + It is useful for downloading vim.org scripts. + Note: This attribute is available in raw type only. + + Examples: |:NeoBundle-examples| +> + NeoBundle 'git_repository_uri' + NeoBundle 'script_name' + NeoBundle 'https://github.com/tpope/vim-fugitive.git' + NeoBundle 'Shougo/neocomplcache', {'depends' : + \ [ 'Shougo/neosnippet.git', + \ ['rstacruz/sparkup', {'rtp': 'vim'}], + \ ]} + NeoBundle 'github:Shougo/vimshell' + + " Pushable github repository. + NeoBundle 'git@github.com:Shougo/neocomplcache.git' + + " For bitbucket hg repository. + NeoBundle 'bitbucket:ns9tks/vim-fuzzyfinder' + NeoBundle 'https://bitbucket.org/ns9tks/vim-fuzzyfinder' + + " For bitbucket git repository (.git is needed). + NeoBundle 'bitbucket:kh3phr3n/vim-qt-syntax.git' + NeoBundle 'https://bitbucket.org/kh3phr3n/vim-qt-syntax.git' + + " For raw repository. + NeoBundle 'https://raw.github.com/m2ym/rsense/master/etc/rsense.vim', + \ {'script_type' : 'plugin'} + + " For gist repository. + NeoBundle 'gist:Shougo/656148', { + \ 'name': 'everything.vim', + \ 'script_type': 'plugin'} + NeoBundle 'gist:355360', { + \ 'name': 'ambicmd.vim', + \ 'script_type': 'plugin'} +< + Neobundle supports revision (or branch) lock. + Note: The revision (or branch) is checked out in + install/update. + Note: You can either specify the revision manually or set the + to revision "master" to restore a plugin. +> + NeoBundle 'Shougo/vimshell', '3787e5' + NeoBundle 'Shougo/vimshell', 'master' +< + If type is "none", neobundle does not update + automatically (like pathogen.vim). See also |NeoBundleLocal|. +> + NeoBundle 'muttator', {'type' : 'none', 'base' : '~/.vim/bundle'} +< + Note: To use hg commands for git repository, please use this. +> + NeoBundle 'https://github.com/Shougo/neobundle.vim.git', {'type': 'hg'} +< + *neobundle-options-type__depth* + type__depth (Number) + History depth for "git clone". + If omitted, |g:neobundle#types#git#clone_depth| is used. + If it is than 0, neobundle clones the repository by shallow + clone. Shallow clone feature saves your repository clone time. + But it have problems in some repository. + + See below issues: + https://github.com/Shougo/neobundle.vim/issues/81 + https://github.com/Homebrew/homebrew/issues/12024 + + Note: This attribute is available in git type only. + +============================================================================== +EXAMPLES *neobundle-examples* +> + " Note: Skip initialization for vim-tiny or vim-small. + if 0 | endif + + if has('vim_starting') + if &compatible + set nocompatible " Be iMproved + endif + set runtimepath+={path to neobundle directory} + endif + + call neobundle#begin(expand('~/.vim/bundle')) + + " Let neobundle manage neobundle + NeoBundleFetch 'Shougo/neobundle.vim' + + " My Bundles here: + " Refer to |:NeoBundle-examples|. + " Note: You don't set neobundle setting in .gvimrc! + + " ... + + call neobundle#end() + + filetype plugin indent on " Required! + + " Installation check. + NeoBundleCheck + + "... + + if !has('vim_starting') + " Call on_source hook when reloading .vimrc. + call neobundle#call_hook('on_source') + endif +< +============================================================================== +MIGRATING FROM PATHOGEN *neobundle-migrate-from-pathogen* + +Here are a few tips if you want to migrate from a |pathogen| based +installation to neobundle. + +You might want to use a different/non-default directory for neobundle: > + + set rtp+=~/.vim/bundle/neobundle + call neobundle#begin(expand('~/.vim/neobundle')) +< +This allows you to keep `~/.vim/bundle` in place while migrating. + +If you are using Git submodules currently, you can use a shell command like +the following to automatically generate your NeoBundle statements: > + + while read p url; do \ + bundle_name="${url#*://github.com/}"; \ + dir="$(command git config -f .gitmodules --get ${p%.url}.path)"; \ + echo "NeoBundle '$bundle_name', { 'directory': '${dir##*/}' }"; \ + done < <(command git config -f .gitmodules \ + --get-regexp 'submodule.vim/bundle/\S+.(url)' | sort) +< +This uses the "submodule.*" urls and path from your .gitmodules sections that +start with `submodule.vim/bundle/`. +It sets the directory option explicitly to the name you were using before +(see |neobundle-options-directory|), which is useful if you want to compare +your old bundles directory with the one managed by neocomplete later. + +The output looks like this: > + NeoBundle 'tpope/vim-abolish.git', { 'directory': 'abolish' } +> +============================================================================== +UNITE SOURCES *neobundle-unite-sources* + +Here let me explain about a source for |unite| provided in neobundle. + + *neobundle-unite-source-neobundle* +neobundle + Nominates bundles as a candidate. + + Note: + If argument is bang(!), print plugins status. + + https://github.com/Shougo/vimproc.vim + + *neobundle-unite-source-neobundle-install* +neobundle/install + Install configured plugins asynchronously. + It supports neovim async jobs feature. + + Note: Installing the |vimproc| plugin or using neovim is + recommended. + + If argument is bang(!), it will install and update all plugins. + + Source arguments: + bundle names (fuzzy searched). + + Example: +> + :Unite neobundle/install:! + :Unite neobundle/install:neocomplcache + :Unite neobundle/install:neocomplcache:unite.vim +< + If you use the source with "-auto-quit" option, the unite + buffer will close automatically. +> + :Unite neobundle/install -auto-quit +< + *neobundle-unite-source-neobundle-log* +neobundle/log + Print previous neobundle install logs. + And you can jump the diff URI in github. + + *neobundle-unite-source-neobundle-update* +neobundle/update + Install and update configured plugins asynchronously, except + for outdated ones or those with the "frozen" option. + It supports neovim async jobs feature. + Note: This source is the same as "neobundle/install:!". + Note: Installing the |vimproc| plugin or using neovim is + recommended. + + If argument is bang(!), it will not be with fuzzy search. + If argument is "all", it will update all plugins. + + If you use the source with "-auto-quit" option, the unite + buffer will close automatically. +> + :Unite neobundle/update -log -wrap -auto-quit +< + *neobundle-unite-source-neobundle-search* +neobundle/search + Search plugin settings from sources. + Note: This source requires "curl" or "wget" command. + Note: If you get errors in this source, please refresh the + cache file by |(unite_redraw)|. + + Source arguments: + source names. + + Following source names are available: + "vim_scripts_org": + Search plugins settings from "http://vim-scripts.org". + "github": + Search plugins settings from "https://github.org/". + "metadata": + Search plugins settings from converted metadata in + "https://bitbucket.org/vimcommunity/vim-pi/". + + *neobundle-unite-source-neobundle-lazy* +neobundle/lazy + List lazy configured plugins (not sourced by + |:NeoBundleSource|). + + *unite-kind-neobundle* +neobundle An interface for neobundle bundles. It is used in + neobundle source and neobundle/lazy sources. + update Update bundles (Default action) + delete Delete bundles + preview view the plugin documentation + reinstall Reinstall bundles + narrow Narrow bundle files + edit Browse bundle directory + start Browse github plugin page + +Actions for each of the sources + +neobundle/search *unite-action-neobundle-search* + yank Yank plugin settings (Default action). + install Direct install plugins from repository. + Note: The settings are saved in "extra_bundles.vim" in + |neobundle#begin()| directory. + start Browse github plugin page. + + Note: If you use the install action, you cannot customize the bundle + settings. + +neobundle/lazy *unite-action-neobundle-lazy* + source Source plugin files (Default action) + +============================================================================== +FAQ *neobundle-faq* + +Q: What's the neobundle advantage for Vundle or other plugin management +system? + +A: neobundle solves some problems in Vundle or other plugin management system. +But you must know they are huge and complex features. + + 1. Plugin prefixed command name (:Bundle vs :NeoBundle). + https://github.com/gmarik/Vundle.vim/issues/76 + 2. Support vimproc (asynchronous update/install). + https://github.com/gmarik/Vundle.vim/issues/259 + 3. Support unite.vim interface (update/install/search). + 4. Support revision lock feature. + https://github.com/gmarik/Vundle.vim/issues/35 + 5. Support other VCS (Subversion/Git). + https://github.com/gmarik/Vundle.vim/pull/134 + https://github.com/gmarik/Vundle.vim/pull/268 + 6. Support lazy initialization for optimizing startup time. + https://github.com/gmarik/Vundle.vim/issues/364 + https://github.com/gmarik/Vundle.vim/pull/98 + +Q: I want to manage the rsense Vim plugin using neobundle. + +A: Use |neocomplcache-rsense|. Installation and settings can be found in the +neocomplcache-rsense docs. +Note: neocomplcache-rsense depends |neocomplcache| plugin. + +https://github.com/Shougo/neocomplcache-rsense + +Q: Vim freezes when a NeoBundle command is run with a typo in the repo name. + +A: It's a git feature. Git awaits user input when the repo name is +wrong. You can install |vimproc| to keep your Vim from freezing: + https://github.com/Shougo/vimproc.vim + +Q: Duplicated error was printed when sourcing .vimrc. + +A: Your .vimrc was wrong. You must reset neobundle setting by +|neobundle#begin()| in .vimrc. +Note: You must not call |neobundle#begin()| inside a "has('vim_starting')" +block. +> + if has('vim_starting') + " This is wrong neobundle#begin(). + "call neobundle#begin(expand('~/.vim/bundle')) + endif + + " This is OK. + call neobundle#begin(expand('~/.vim/bundle')) +< + +Q: I want to compile vimproc automatically. + +A: +> + NeoBundle 'Shougo/vimproc.vim', { + \ 'build' : { + \ 'windows' : 'tools\\update-dll-mingw', + \ 'cygwin' : 'make -f make_cygwin.mak', + \ 'mac' : 'make -f make_mac.mak', + \ 'unix' : 'make -f make_unix.mak', + \ }, + \ } +< + +Q: What's the "outdated" plugin? + +A: Last update time is older than one week -> Automatic updates are disabled +until one day from the last update. +Last update time is older within one week -> Automatic updates are every time. +Note: If you use update with name or use "all" argument in neobundle/update +source or use "!" in |:NeoBundleUpdate| command, this feature will be +disabled; it forces updates them. + +Q: I want to update messages in unite buffer. + +A: +> + Unite -log -wrap neobundle/update +< + +Q: neobundle.vim is not worked in Debian/Ubuntu Linux... + +A: Did you use "debian.vim"? "debian.vim" changes 'runtimepath'. +So it conflicts with neobundle. You should not use "debian.vim". + +Q: neobundle.vim fails update in submodule repository. + +A: neobundle.vim supports submodule repository. But I think the repository was +changed recently from non-use submodule to use submodule. You must reinstall +the repository. + +Q: I want to install github plugins with Subversion. + +A: +> + NeoBundle 'thinca/vim-localrc', {'type' : 'svn'} +< +Q: I want to add absolute path in 'runtimepath' with |:NeoBundle| and +|:NeoBundleLazy|. +https://github.com/Shougo/neobundle.vim/issues/136 + +A: You can use "none" type. > + NeoBundle '/absolute/path/to/plugin', { 'type' : 'none' } + +Q: Problem with lazy loading of matchit plugin. +https://github.com/Shougo/neobundle.vim/issues/153 + +A: +> + NeoBundle 'matchit.zip', { + \ 'on_map' : ['%', 'g%'] + \ } + let bundle = neobundle#get('matchit.zip') + function! bundle.hooks.on_post_source(bundle) + silent! execute 'doautocmd Filetype' &filetype + endfunction +< + +Q: Cannot load colorscheme when reloading .vimrc. +https://github.com/Shougo/neobundle.vim/issues/157 + +A: You must write :NeoBundle lines before filetype plugin indent on and syntax +enable. +> + filetype plugin indent on + + NeoBundle 'tomasr/molokai' + ... + + syntax enable + colorscheme molokai +< + +Q: Timeout on github makes Vim terribly slow if the repository is not found in +console Vim. +https://github.com/Shougo/neobundle.vim/issues/175 + +A: |vimproc| and |system()| uses input redirection. But git ignores it when +you used https protocol in console Vim. So it freezes. I think it is bad +feature in git. I cannot fix it. You should change +|g:neobundle#types#git#default_protocol| to "git". + +Q: I want to use shallow clone in git. + +A: See |neobundle-options-type__depth|. + +Q: I want to use lockfile feature like "Gemfile.lock" in neobundle. +https://github.com/Shougo/neobundle.vim/issues/222 + +A: You can copy "NeoBundle.lock" to another machine from neobundle base path +directory. It is used when install plugins. + +Q: neobundle#begin() breaks plugin function calls. +https://github.com/Shougo/neobundle.vim/issues/330 + +A: You must use the functions after |neobundle#end()|. +Because, the plugins are loaded when neobundle calls |neobundle#end()|. + +Q: Fails submoduled repository clone like YouCompleteMe. + +A: I think you use the submodule repository in proxy environment. + +https://github.com/ekg/freebayes/issues/63 +> + $ git config --global url.https://github.com/.insteadOf git://github.com/ +< +Q: Colorscheme does not load below code. > + NeoBundle 'mrkn256.vim' + colorscheme mrkn256 + ... + neobundle#end() + +A: 'runtimepath' is set on |neobundle#end()|. So it is not set when the +colorscheme executed. You can use |neobundle-options-force| for it or write +|:colorscheme| command after |neobundle#end()|. + +Q: fugitive does not work using neobundle. Please help! > + NeoBundle 'tpope/vim-fugitive' + +A: You must specify |neobundle-options-augroup| like this. > + " fugitive uses augroup fugitive. + NeoBundle 'tpope/vim-fugitive', { 'augroup' : 'fugitive'} + +Q: I setup gVim-only colorscheme but neobundle doesn't load it. + +A: neobundle can't load colorschemes automatically. So you can't use +|:NeoBundleLazy| for colorschemes. + +Q: I want to use "git" or "http" protocol instead of "https". + +A: No, you cannot. + +Q: Why neobundle only accepts "https" or "ssh"? + +A: https://glyph.twistedmatrix.com/2015/11/editor-malware.html + +Q: I want to autoload vim-gnupg + +A: vim-gnupg uses |BufReadCmd| and |FileReadCmd| autocmd. You must specify +the autocmd. > + autocmd BufReadCmd,FileReadCmd *.gpg,*.asc,*.pgp + \ NeoBundleSource vim-gnupg | doautocmd BufReadCmd + autocmd FileReadCmd *.gpg,*.asc,*.pgp + \ NeoBundleSource vim-gnupg | doautocmd FileReadCmd + +Q: Where is :NeoBundleClean command? +https://github.com/Shougo/neobundle.vim/issues/501 + +A: It is removed because it is dangerous. + +Q: Why the install script does not use "curl | bash" ? +https://github.com/Shougo/neobundle.vim/pull/515 + +A: https://www.idontplaydarts.com/2016/04/detecting-curl-pipe-bash-server-side/ + +============================================================================== +vim:tw=78:ts=8:ft=help:norl:noet:fen: diff --git a/.vim/bundle/neobundle.vim/plugin/neobundle.vim b/.vim/bundle/neobundle.vim/plugin/neobundle.vim new file mode 100644 index 0000000..971e116 --- /dev/null +++ b/.vim/bundle/neobundle.vim/plugin/neobundle.vim @@ -0,0 +1,60 @@ +"============================================================================= +" FILE: neobundle.vim +" AUTHOR: Shougo Matsushita +" 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 diff --git a/.vim/bundle/neobundle.vim/test/commands.vim b/.vim/bundle/neobundle.vim/test/commands.vim new file mode 100644 index 0000000..3a0da22 --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/commands.vim @@ -0,0 +1,117 @@ +" Basic commands test. +set verbose=1 + +let path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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/* + diff --git a/.vim/bundle/neobundle.vim/test/lock.vim b/.vim/bundle/neobundle.vim/test/lock.vim new file mode 100644 index 0000000..7dd4bfb --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/lock.vim @@ -0,0 +1,35 @@ +" Lock file test. +set verbose=1 + +let path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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 diff --git a/.vim/bundle/neobundle.vim/test/parse.vim b/.vim/bundle/neobundle.vim/test/parse.vim new file mode 100644 index 0000000..cb7dc57 --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/parse.vim @@ -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' : '' }]) + call s:assert.equals(bundle.on_map, ['']) + 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: diff --git a/.vim/bundle/neobundle.vim/test/sample.vim b/.vim/bundle/neobundle.vim/test/sample.vim new file mode 100644 index 0000000..ca46962 --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/sample.vim @@ -0,0 +1,39 @@ +" Sample configurations test. +set verbose=1 + +let path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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! + diff --git a/.vim/bundle/neobundle.vim/test/source.vim b/.vim/bundle/neobundle.vim/test/source.vim new file mode 100644 index 0000000..eb6932e --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/source.vim @@ -0,0 +1,95 @@ +" Source test. +set verbose=1 + +let path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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 + diff --git a/.vim/bundle/neobundle.vim/test/toml.vim b/.vim/bundle/neobundle.vim/test/toml.vim new file mode 100644 index 0000000..1624f5f --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/toml.vim @@ -0,0 +1,49 @@ +let s:suite = themis#suite('toml') +let s:assert = themis#helper('assert') + +let g:path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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 + diff --git a/.vim/bundle/neobundle.vim/test/tsort.vim b/.vim/bundle/neobundle.vim/test/tsort.vim new file mode 100644 index 0000000..01650aa --- /dev/null +++ b/.vim/bundle/neobundle.vim/test/tsort.vim @@ -0,0 +1,182 @@ +let s:suite = themis#suite('tsort') +let s:assert = themis#helper('assert') + +let g:path = expand('~/test-bundle/'.fnamemodify(expand(''), ':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 +