SpaceVim/bundle/neobundle.vim/doc/neobundle.txt

*neobundle.txt*	Next generation Vim package manager

Version: 4.0
Author:  Shougo <Shougo.Matsu at gmail.com>
         Copyright (C) 2010 http://github.com/gmarik
License: MIT license  {{{
    Permission is hereby granted, free of charge, to any person obtaining
    a copy of this software and associated documentation files (the
    "Software"), to deal in the Software without restriction, including
    without limitation the rights to use, copy, modify, merge, publish,
    distribute, sublicense, and/or sell copies of the Software, and to
    permit persons to whom the Software is furnished to do so, subject to
    the following conditions:
    The above copyright notice and this permission notice shall be included
    in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
}}}

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 works well 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 = '<Plug>'

		[[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' : '<Plug>',
	      \ }
	nmap gs <Plug>(open-browser-wwwsearch)

	let bundle = neobundle#get('open-browser.vim')
	function! bundle.hooks.on_source(bundle)
	  nnoremap <Plug>(open-browser-wwwsearch)
	        \ :<C-u>call <SID>www_search()<CR>
	  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 <Plug>(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' : '<Plug>',
		      \ '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 "<Plug>(ref-" instead of
		"<Plug>(ref-back)" and so on.

		Note: You can use "<Plug>" keyword as {mapping}. If
		{mapping} is "<Plug>", "<Plug>(normalized_name" is
		used.
		For example: >
		" It is same as "'mappings' : '<Plug>(anzu'
		NeoBundle 'osyo-manga/vim-anzu', {
		  \'on_map': '<Plug>'}
<
		Note: You cannot use lazy <Plug> mappings twice.
		For example: >
		NeoBundle 'osyo-manga/vim-anzu', {
		  \ 'on_map': '<Plug>(anzu-'}
		" Not working!!
		nmap n <Plug>(anzu-jump-n)<Plug>(anzu-echo-search-status)zv
		nmap N <Plug>(anzu-jump-N)<Plug>(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' : [
	      \   '<Plug>(smartword-'']
	      \ }
	NeoBundle 'Shougo/vimshell',{
	      \ 'depends' : 'Shougo/vimproc.vim',
	      \ 'on_cmd' : [{ 'name' : 'VimShell',
	      \                 'complete' : 'customlist,vimshell#complete'},
	      \               'VimShellExecute', 'VimShellInteractive',
	      \               'VimShellTerminal', 'VimShellPop'],
	      \ 'on_map' : '<Plug>'
	      \ })
	NeoBundle 'Shougo/vimfiler', {
	      \ 'depends' : 'Shougo/unite.vim',
	      \ 'on_cmd' : [{ 'name' : 'VimFiler',
	      \                 'complete' : 'customlist,vimfiler#complete' },
	      \               'VimFilerExplorer',
	      \               'Edit', 'Read', 'Source', 'Write'],
	      \ 'on_map' : '<Plug>',
	      \ 'on_path' : '.*',
	      \ }
	NeoBundle 'Shougo/junkfile.vim', {
	      \   'on_cmd' : 'JunkfileOpen',
	      \ }
	NeoBundle 'tyru/winmove.vim', {
	      \ 'on_map' : [
	      \   ['n', '<Plug>']],
	      \ 'gui' : 1,
	      \ 'augroup' : 'winmove',
	      \ }
	NeoBundle 'sophacles/vim-processing', {
	      \'on_path': '\.pde$'
	      \}
	NeoBundle 'LeafCage/cmdlineplus.vim', {
	      \ 'on_map': [['c', '<Plug>']]}
<
						*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 |<Plug>(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: