Merge 00d3f0ada6 into d863d07832

Close #1152

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: junegunn

.github/ISSUE_TEMPLATE.md

@@ -10,7 +10,12 @@ Explain the problem here ...
 
 ------------------------------
 
-<!-- Put the contents of `:version` below -->
+<!-- Paste your Plug block (from `call plug#begin()` to `call plug#end()`) -->
+```
+
+```
+
+<!-- Paste the contents of `:version` below -->
 ```
 
 ```
@@ -24,7 +29,7 @@ Explain the problem here ...
 - OS:
     - [ ] All/Other
     - [ ] Linux
-    - [ ] OS X
+    - [ ] macOS
     - [ ] Windows
 - Vim:
     - [ ] Terminal Vim

.gitignore

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

README.md

@@ -1,16 +1,44 @@
-<img src="https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.png" height="75" alt="vim-plug">[![travis-ci](https://travis-ci.org/junegunn/vim-plug.svg?branch=master)](https://travis-ci.org/junegunn/vim-plug)
-===
+<div align="center">
+<sup>Special thanks to:</sup>
+<br>
+<br>
+<a href="https://warp.dev/?utm_source=github&utm_medium=referral&utm_campaign=vimplug_20240209">
+  <div>
+    <img src="https://raw.githubusercontent.com/junegunn/i/master/warp.png" width="300" alt="Warp">
+  </div>
+  <b>Warp is a modern, Rust-based terminal with AI built in so you and your team can build great software, faster.</b>
+  <div>
+    <sup>Visit warp.dev to learn more.</sup>
+  </div>
+</a>
+<br>
+<hr>
+</div>
+<br>
+
+<h1 title="vim-plug">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./plug-dark.png">
+    <img src="./plug.png" height="75" alt="vim-plug">
+  </picture>
+  <a href="https://github.com/junegunn/vim-plug/actions/workflows/test.yml?query=branch%3Amaster">
+    <img src="https://img.shields.io/github/actions/workflow/status/junegunn/vim-plug/test.yml?branch=master">
+  </a>
+</h1>
 
 A minimalist Vim plugin manager.
 
 <img src="https://raw.githubusercontent.com/junegunn/i/master/vim-plug/installer.gif" height="450">
 
-### Pros.
+## Pros.
 
-- Easy to set up: Single file. No boilerplate code required.
-- Easy to use: Concise, intuitive syntax
+- Minimalist design
+    - Just one file with no dependencies. Super easy to set up.
+    - Concise, intuitive syntax that you can learn within minutes. No boilerplate code required.
+    - No feature bloat
+- Extremely stable with flawless backward compatibility
+    - Works perfectly with all versions of Vim since 2006 and all versions of Neovim ever released
 - [Super-fast][40/4] parallel installation/update
-  (with any of `+job`, `+python`, `+python3`, `+ruby`, or [Neovim][nv])
 - Creates shallow clones to minimize disk space usage and download time
 - On-demand loading for [faster startup time][startup-time]
 - Can review and rollback updates
@@ -19,17 +47,19 @@ A minimalist Vim plugin manager.
 - Support for externally managed plugins
 
 [40/4]: https://raw.githubusercontent.com/junegunn/i/master/vim-plug/40-in-4.gif
-[nv]: http://neovim.org/
 [startup-time]: https://github.com/junegunn/vim-startuptime-benchmark#result
 
-### Installation
+## Installation
 
 [Download plug.vim](https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim)
 and put it in the "autoload" directory.
 
-#### Vim
+<details>
+<summary>Click to see the instructions</summary>
 
-###### Unix
+### Vim
+
+#### Unix
 
 ```sh
 curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
@@ -41,59 +71,94 @@ file as suggested [here][auto].
 
 [auto]: https://github.com/junegunn/vim-plug/wiki/tips#automatic-installation
 
-###### Windows (PowerShell)
+#### Windows (PowerShell)
 
 ```powershell
 iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
     ni $HOME/vimfiles/autoload/plug.vim -Force
 ```
 
-#### Neovim
+### Neovim
 
-###### Unix, Linux
+#### Unix, Linux
 
 ```sh
 sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
        https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
 ```
 
-###### Linux (Flatpak)
+#### Linux (Flatpak)
 
 ```sh
 curl -fLo ~/.var/app/io.neovim.nvim/data/nvim/site/autoload/plug.vim --create-dirs \
     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
 ```
 
-###### Windows (PowerShell)
+#### Windows (PowerShell)
 
 ```powershell
 iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
     ni "$(@($env:XDG_DATA_HOME, $env:LOCALAPPDATA)[$null -eq $env:XDG_DATA_HOME])/nvim-data/site/autoload/plug.vim" -Force
 ```
 
+</details>
+
+## Usage
+
+Add a vim-plug section to your `~/.vimrc` (or `~/.config/nvim/init.vim` for Neovim)
+
+1. Begin the section with `call plug#begin()`
+1. List the plugins with `Plug` commands
+1. End the section with `call plug#end()`
+
+For example,
+
+```vim
+call plug#begin()
+
+" List your plugins here
+Plug 'tpope/vim-sensible'
+
+call plug#end()
+```
+
+Reload the file or restart Vim, then you can,
+
+* `:PlugInstall` to install the plugins
+* `:PlugUpdate` to install or update the plugins
+* `:PlugDiff` to review the changes from the last update
+* `:PlugClean` to remove plugins no longer in the list
+
+> [!NOTE]
+> That's basically all you need to know to get started. The rest of the
+> document is for advanced users who want to know more about the features and
+> options.
+
+> [!TIP]
+> `plug#end()` automatically executes `filetype plugin indent on` and `syntax
+> enable`. We believe this is a good default for most users, but if you don't
+> want this behavior, you can revert the settings after the call.
+>
+> ```vim
+> call plug#end()
+> filetype indent off   " Disable file-type-specific indentation
+> syntax off            " Disable syntax highlighting
+> ```
+
 ### Getting Help
 
-- See [tutorial] page to learn the basics of vim-plug
+- See [tutorial] page to learn more about the basics of vim-plug
 - See [tips] and [FAQ] pages for common problems and questions
-- See [requirements] page for debugging information & tested configurations
-- Create an [issue](https://github.com/junegunn/vim-plug/issues/new)
 
 [tutorial]: https://github.com/junegunn/vim-plug/wiki/tutorial
 [tips]: https://github.com/junegunn/vim-plug/wiki/tips
 [FAQ]: https://github.com/junegunn/vim-plug/wiki/faq
-[requirements]: https://github.com/junegunn/vim-plug/wiki/requirements
 
-### Usage
+## Examples
 
-Add a vim-plug section to your `~/.vimrc` (or `stdpath('config') . '/init.vim'` for Neovim)
+The following examples demonstrate the additional features of vim-plug.
 
-1. Begin the section with `call plug#begin([PLUGIN_DIR])`
-1. List the plugins with `Plug` commands
-1. `call plug#end()` to update `&runtimepath` and initialize plugin system
-    - Automatically executes `filetype plugin indent on` and `syntax enable`.
-      You can revert the settings after the call. e.g. `filetype indent off`, `syntax off`, etc.
-
-#### Example
+### Vim script example
 
 ```vim
 call plug#begin()
@@ -107,66 +172,131 @@ call plug#begin()
 
 " Make sure you use single quotes
 
-" Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
-Plug 'junegunn/vim-easy-align'
+" Shorthand notation for GitHub; translates to https://github.com/junegunn/seoul256.vim.git
+Plug 'junegunn/seoul256.vim'
 
 " Any valid git URL is allowed
-Plug 'https://github.com/junegunn/vim-github-dashboard.git'
-
-" Multiple Plug commands can be written in a single line using | separators
-Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
-
-" On-demand loading
-Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
-Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
-
-" Using a non-default branch
-Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
+Plug 'https://github.com/junegunn/vim-easy-align.git'
 
 " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
 Plug 'fatih/vim-go', { 'tag': '*' }
 
-" Plugin options
-Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
+" Using a non-default branch
+Plug 'neoclide/coc.nvim', { 'branch': 'release' }
 
-" Plugin outside ~/.vim/plugged with post-update hook
+" Use 'dir' option to install plugin in a non-default directory
+Plug 'junegunn/fzf', { 'dir': '~/.fzf' }
+
+" Post-update hook: run a shell command after installing or updating the plugin
 Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 
+" Post-update hook can be a lambda expression
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+
+" If the vim plugin is in a subdirectory, use 'rtp' option to specify its path
+Plug 'nsf/gocode', { 'rtp': 'vim' }
+
+" On-demand loading: loaded when the specified command is executed
+Plug 'preservim/nerdtree', { 'on': 'NERDTreeToggle' }
+
+" On-demand loading: loaded when a file with a specific file type is opened
+Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
+
 " Unmanaged plugin (manually installed and updated)
 Plug '~/my-prototype-plugin'
 
-" Initialize plugin system
+" Call plug#end to update &runtimepath and initialize the plugin system.
+" - It automatically executes `filetype plugin indent on` and `syntax enable`
 call plug#end()
+" You can revert the settings after the call like so:
+"   filetype indent off   " Disable file-type-specific indentation
+"   syntax off            " Disable syntax highlighting
+
+" Color schemes should be loaded after plug#end().
+" We prepend it with 'silent!' to ignore errors when it's not yet installed.
+silent! colorscheme seoul256
 ```
 
-Reload .vimrc and `:PlugInstall` to install plugins.
+### Lua example for Neovim
 
-### Commands
+In Neovim, you can write your configuration in a Lua script file named
+`init.lua`. The following code is the Lua script equivalent to the Vim script
+example above.
+
+```lua
+local vim = vim
+local Plug = vim.fn['plug#']
+
+vim.call('plug#begin')
+
+-- Shorthand notation for GitHub; translates to https://github.com/junegunn/seoul256.vim.git
+Plug('junegunn/seoul256.vim')
+
+-- Any valid git URL is allowed
+Plug('https://github.com/junegunn/vim-easy-align.git')
+
+-- Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
+Plug('fatih/vim-go', { ['tag'] = '*' })
+
+-- Using a non-default branch
+Plug('neoclide/coc.nvim', { ['branch'] = 'release' })
+
+-- Use 'dir' option to install plugin in a non-default directory
+Plug('junegunn/fzf', { ['dir'] = '~/.fzf' })
+
+-- Post-update hook: run a shell command after installing or updating the plugin
+Plug('junegunn/fzf', { ['dir'] = '~/.fzf', ['do'] = './install --all' })
+
+-- Post-update hook can be a lambda expression
+Plug('junegunn/fzf', { ['do'] = function()
+  vim.fn['fzf#install']()
+end })
+
+-- If the vim plugin is in a subdirectory, use 'rtp' option to specify its path
+Plug('nsf/gocode', { ['rtp'] = 'vim' })
+
+-- On-demand loading: loaded when the specified command is executed
+Plug('preservim/nerdtree', { ['on'] = 'NERDTreeToggle' })
+
+-- On-demand loading: loaded when a file with a specific file type is opened
+Plug('tpope/vim-fireplace', { ['for'] = 'clojure' })
+
+-- Unmanaged plugin (manually installed and updated)
+Plug('~/my-prototype-plugin')
+
+vim.call('plug#end')
+
+-- Color schemes should be loaded after plug#end().
+-- We prepend it with 'silent!' to ignore errors when it's not yet installed.
+vim.cmd('silent! colorscheme seoul256')
+```
+
+## Commands
 
 | Command                             | Description                                                        |
 | ----------------------------------- | ------------------------------------------------------------------ |
 | `PlugInstall [name ...] [#threads]` | Install plugins                                                    |
 | `PlugUpdate [name ...] [#threads]`  | Install or update plugins                                          |
-| `PlugClean[!]`                      | Remove unlisted plugins (bang version will clean without prompt) |
+| `PlugClean[!]`                      | Remove unlisted plugins (bang version will clean without prompt)   |
 | `PlugUpgrade`                       | Upgrade vim-plug itself                                            |
 | `PlugStatus`                        | Check the status of plugins                                        |
 | `PlugDiff`                          | Examine changes from the previous update and the pending changes   |
 | `PlugSnapshot[!] [output path]`     | Generate script for restoring the current snapshot of the plugins  |
 
-### `Plug` options
+## `Plug` options
 
-| Option                  | Description                                      |
-| ----------------------- | ------------------------------------------------ |
-| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use       |
-| `rtp`                   | Subdirectory that contains Vim plugin            |
-| `dir`                   | Custom directory for the plugin                  |
-| `as`                    | Use different name for the plugin                |
-| `do`                    | Post-update hook (string or funcref)             |
-| `on`                    | On-demand loading: Commands or `<Plug>`-mappings |
-| `for`                   | On-demand loading: File types                    |
-| `frozen`                | Do not update unless explicitly specified        |
+| Option                  | Description                                                 |
+| ----------------------- | ----------------------------------------------------------- |
+| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use                  |
+| `rtp`                   | Subdirectory that contains Vim plugin                       |
+| `dir`                   | Custom directory for the plugin                             |
+| `as`                    | Use different name for the plugin                           |
+| `do`                    | Post-update hook (string or funcref)                        |
+| `on`                    | On-demand loading: Commands or `<Plug>`-mappings            |
+| `for`                   | On-demand loading: File types                               |
+| `frozen`                | Do not remove and do not update unless explicitly specified |
 
-### Global options
+## Global options
 
 | Flag                | Default                           | Description                                            |
 | ------------------- | --------------------------------- | ------------------------------------------------------ |
@@ -174,12 +304,12 @@ Reload .vimrc and `:PlugInstall` to install plugins.
 | `g:plug_timeout`    | 60                                | Time limit of each task in seconds (*Ruby & Python*)   |
 | `g:plug_retries`    | 2                                 | Number of retries in case of timeout (*Ruby & Python*) |
 | `g:plug_shallow`    | 1                                 | Use shallow clone                                      |
-| `g:plug_window`     | `vertical topleft new`            | Command to open plug window                            |
-| `g:plug_pwindow`    | `above 12new`                     | Command to open preview window in `PlugDiff`           |
+| `g:plug_window`     | `-tabnew`                         | Command to open plug window                            |
+| `g:plug_pwindow`    | `vertical rightbelow new`         | Command to open preview window in `PlugDiff`           |
 | `g:plug_url_format` | `https://git::@github.com/%s.git` | `printf` format to build repo URL (Only applies to the subsequent `Plug` commands) |
 
 
-### Keybindings
+## Keybindings
 
 - `D` - `PlugDiff`
 - `S` - `PlugStatus`
@@ -191,19 +321,83 @@ Reload .vimrc and `:PlugInstall` to install plugins.
 - `:PlugDiff`
     - `X` - Revert the update
 
-### Example: A small [sensible](https://github.com/tpope/vim-sensible) Vim configuration
+## Post-update hooks
+
+There are some plugins that require extra steps after installation or update.
+In that case, use the `do` option to describe the task to be performed.
 
 ```vim
-call plug#begin()
-Plug 'tpope/vim-sensible'
-call plug#end()
+Plug 'Shougo/vimproc.vim', { 'do': 'make' }
+Plug 'ycm-core/YouCompleteMe', { 'do': './install.py' }
 ```
 
-### On-demand loading of plugins
+If the value starts with `:`, it will be recognized as a Vim command.
+
+```vim
+Plug 'fatih/vim-go', { 'do': ':GoInstallBinaries' }
+```
+
+To call a Vim function, you can pass a lambda expression like so:
+
+```vim
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+```
+
+If you need more control, you can pass a reference to a Vim function that
+takes a dictionary argument.
+
+```vim
+function! BuildYCM(info)
+  " info is a dictionary with 3 fields
+  " - name:   name of the plugin
+  " - status: 'installed', 'updated', or 'unchanged'
+  " - force:  set on PlugInstall! or PlugUpdate!
+  if a:info.status == 'installed' || a:info.force
+    !./install.py
+  endif
+endfunction
+
+Plug 'ycm-core/YouCompleteMe', { 'do': function('BuildYCM') }
+```
+
+A post-update hook is executed inside the directory of the plugin and only run
+when the repository has changed, but you can force it to run unconditionally
+with the bang-versions of the commands: `PlugInstall!` and `PlugUpdate!`.
+
+> [!TIP]
+> Make sure to escape BARs and double-quotes when you write the `do` option
+> inline as they are mistakenly recognized as command separator or the start of
+> the trailing comment.
+>
+> ```vim
+> Plug 'junegunn/fzf', { 'do': 'yes \| ./install' }
+> ```
+>
+> But you can avoid the escaping if you extract the inline specification using a
+> variable (or any Vim script expression) as follows:
+>
+> ```vim
+> let g:fzf_install = 'yes | ./install'
+> Plug 'junegunn/fzf', { 'do': g:fzf_install }
+> ```
+
+### `PlugInstall!` and `PlugUpdate!`
+
+The installer takes the following steps when installing/updating a plugin:
+
+1. `git clone` or `git fetch` from its origin
+2. Check out branch, tag, or commit and optionally `git merge` remote branch
+3. If the plugin was updated (or installed for the first time)
+    1. Update submodules
+    2. Execute post-update hooks
+
+The commands with the `!` suffix ensure that all steps are run unconditionally.
+
+## On-demand loading of plugins
 
 ```vim
 " NERD tree will be loaded on the first invocation of NERDTreeToggle command
-Plug 'scrooloose/nerdtree', { 'on': 'NERDTreeToggle' }
+Plug 'preservim/nerdtree', { 'on': 'NERDTreeToggle' }
 
 " Multiple commands
 Plug 'junegunn/vim-github-dashboard', { 'on': ['GHDashboard', 'GHActivity'] }
@@ -222,88 +416,48 @@ Plug 'junegunn/goyo.vim', { 'for': 'markdown' }
 autocmd! User goyo.vim echom 'Goyo is now loaded!'
 ```
 
-The `for` option is generally not needed as most plugins for specific file types
-usually don't have too much code in the `plugin` directory. You might want to
-examine the output of `vim --startuptime` before applying the option.
+> [!NOTE]
+> #### Should I set up on-demand loading?
+>
+> You probably don't need to.
+>
+> A properly implemented Vim plugin should already load lazily without any
+> help from a plugin manager (`:help autoload`). So there are few cases where
+> these options actually make much sense. Making a plugin load faster is
+> the responsibility of the plugin developer, not the user. If you find
+> a plugin that takes too long to load, consider opening an issue on the
+> plugin's issue tracker.
+>
+> Let me give you a perspective. The time it takes to load a plugin is usually
+> less than 2 or 3ms on modern computers. So unless you use a very large
+> number of plugins, you are unlikely to save more than 50ms. If you have
+> spent an hour carefully setting up the options to shave off 50ms, you
+> will have to start Vim 72,000 times just to break even. You should ask
+> yourself if that's a good investment of your time.
+>
+> Make sure that you're tackling the right problem by breaking down the
+> startup time of Vim using `--startuptime`.
+>
+> ```sh
+> vim --startuptime /tmp/log
+> ```
+>
+> On-demand loading should only be used as a last resort. It is basically
+> a hacky workaround and is not always guaranteed to work.
 
-### Post-update hooks
+> [!TIP]
+> You can pass an empty list to `on` or `for` option to disable the loading
+> of the plugin. You can manually load the plugin using `plug#load(NAMES...)`
+> function.
+>
+> See https://github.com/junegunn/vim-plug/wiki/tips#loading-plugins-manually
 
-There are some plugins that require extra steps after installation or update.
-In that case, use the `do` option to describe the task to be performed.
 
-```vim
-Plug 'Shougo/vimproc.vim', { 'do': 'make' }
-Plug 'ycm-core/YouCompleteMe', { 'do': './install.py' }
-```
-
-If the value starts with `:`, it will be recognized as a Vim command.
-
-```vim
-Plug 'fatih/vim-go', { 'do': ':GoInstallBinaries' }
-```
-
-If you need more control, you can pass a reference to a Vim function that
-takes a single argument.
-
-```vim
-function! BuildYCM(info)
-  " info is a dictionary with 3 fields
-  " - name:   name of the plugin
-  " - status: 'installed', 'updated', or 'unchanged'
-  " - force:  set on PlugInstall! or PlugUpdate!
-  if a:info.status == 'installed' || a:info.force
-    !./install.py
-  endif
-endfunction
-
-Plug 'ycm-core/YouCompleteMe', { 'do': function('BuildYCM') }
-```
-
-Both forms of post-update hook are executed inside the directory of the plugin
-and only run when the repository has changed, but you can force it to run
-unconditionally with the bang-versions of the commands: `PlugInstall!` and
-`PlugUpdate!`.
-
-Make sure to escape BARs and double-quotes when you write the `do` option inline
-as they are mistakenly recognized as command separator or the start of the
-trailing comment.
-
-```vim
-Plug 'junegunn/fzf', { 'do': 'yes \| ./install' }
-```
-
-But you can avoid the escaping if you extract the inline specification using a
-variable (or any Vimscript expression) as follows:
-
-```vim
-let g:fzf_install = 'yes | ./install'
-Plug 'junegunn/fzf', { 'do': g:fzf_install }
-```
-
-### `PlugInstall!` and `PlugUpdate!`
-
-The installer takes the following steps when installing/updating a plugin:
-
-1. `git clone` or `git fetch` from its origin
-2. Check out branch, tag, or commit and optionally `git merge` remote branch
-3. If the plugin was updated (or installed for the first time)
-    1. Update submodules
-    2. Execute post-update hooks
-
-The commands with the `!` suffix ensure that all steps are run unconditionally.
-
-### Articles
-
-- [Writing my own Vim plugin manager](http://junegunn.kr/2013/09/writing-my-own-vim-plugin-manager)
-- [Vim plugins and startup time](http://junegunn.kr/2014/07/vim-plugins-and-startup-time)
-- ~~[Thoughts on Vim plugin dependency](http://junegunn.kr/2013/09/thoughts-on-vim-plugin-dependency)~~
-    - *Support for Plugfile has been removed since 0.5.0*
-
-### Collaborators
+## Collaborators
 
 - [Jan Edmund Lazo](https://github.com/janlazo) - Windows support
 - [Jeremy Pallats](https://github.com/starcraftman) - Python installer
 
-### License
+## License
 
 MIT

doc/plug.txt

@@ -1,136 +1,114 @@
-plug.txt	plug	Last change: January 3 2022
+plug.txt	plug	Last change: Jun 1 2024
 PLUG - TABLE OF CONTENTS                                         *plug* *plug-toc*
 ==============================================================================
 
-  vim-plug
-    Pros.
-    Installation
-      Vim
-        Unix
-        Windows (PowerShell)
-      Neovim
-        Unix
-        Windows (PowerShell)
-    Getting Help
-    Usage
-      Example
-    Commands
-    Plug options
-    Global options
-    Keybindings
-    Example: A small sensible Vim configuration
-    On-demand loading of plugins
-    Post-update hooks
-    PlugInstall! and PlugUpdate!
-    Articles
-    Collaborators
-    License
+  vim-plug                          |vim-plug|
+    Pros.                           |plug-pros|
+    Installation                    |plug-installation|
+    Usage                           |plug-usage|
+      Getting Help                  |plug-getting-help|
+    Examples                        |plug-examples|
+      Vim script example            |plug-vim-script-example|
+      Lua example for Neovim        |plug-lua-example-for-neovim|
+    Commands                        |plug-commands|
+    Plug options                    |plug-options|
+    Global options                  |plug-global-options|
+    Keybindings                     |plug-keybindings|
+    Post-update hooks               |plug-post-update-hooks|
+      PlugInstall! and PlugUpdate!  |pluginstall-and-plugupdate|
+    On-demand loading of plugins    |plug-on-demand-loading-of-plugins|
+    Collaborators                   |plug-collaborators|
+    License                         |plug-license|
 
 VIM-PLUG                                                              *vim-plug*
 ==============================================================================
 
 A minimalist Vim plugin manager.
 
-https://raw.githubusercontent.com/junegunn/i/master/vim-plug/installer.gif
 
+PROS.                                                                *plug-pros*
+==============================================================================
 
-< Pros. >_____________________________________________________________________~
-                                                                     *plug-pros*
-
- - Easy to set up: Single file. No boilerplate code required.
- - Easy to use: Concise, intuitive syntax
- - {Super-fast}{1} parallel installation/update (with any of `+job`, `+python`,
-   `+python3`, `+ruby`, or {Neovim}{2})
+ - Minimalist design
+   - Just one file with no dependencies. Super easy to set up.
+   - Concise, intuitive syntax that you can learn within minutes. No
+     boilerplate code required.
+   - No feature bloat
+ - Extremely stable with flawless backward compatibility
+   - Works perfectly with all versions of Vim since 2006 and all versions of
+     Neovim ever released
+ - {Super-fast}{1} parallel installation/update
  - Creates shallow clones to minimize disk space usage and download time
- - On-demand loading for {faster startup time}{3}
+ - On-demand loading for {faster startup time}{2}
  - Can review and rollback updates
  - Branch/tag/commit support
  - Post-update hooks
  - Support for externally managed plugins
 
   {1} https://raw.githubusercontent.com/junegunn/i/master/vim-plug/40-in-4.gif
-  {2} http://neovim.org/
-  {3} https://github.com/junegunn/vim-startuptime-benchmark#result
+  {2} https://github.com/junegunn/vim-startuptime-benchmark#result
 
 
-< Installation >______________________________________________________________~
-                                                             *plug-installation*
+INSTALLATION                                                 *plug-installation*
+==============================================================================
 
-{Download plug.vim}{4} and put it in the "autoload" directory.
+{Download plug.vim}{3} and put it in the "autoload" directory.
 
-       {4} https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
+       {3} https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
 
 
-Vim~
-                                                                      *plug-vim*
+USAGE                                                               *plug-usage*
+==============================================================================
 
+Add a vim-plug section to your `~/.vimrc` (or `init.vim` for Neovim)
 
->> Unix~
+                                                           *plug#begin* *plug#end*
+
+ 1. Begin the section with `call plug#begin()`
+ 2. List the plugins with `Plug` commands
+ 3. End the section with `call plug#end()`
+
+For example,
 >
-    curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
-        https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
+    call plug#begin()
+
+    " List your plugins here
+    Plug 'tpope/vim-sensible'
+
+    call plug#end()
 <
-You can automate the process by putting the command in your Vim configuration
-file as suggested {here}{5}.
+Reload the file or restart Vim, then you can,
 
-     {5} https://github.com/junegunn/vim-plug/wiki/tips#automatic-installation
+                                            *:PlugInstall* *:PlugUpdate* *:PlugDiff*
 
+ - `:PlugInstall` to install the plugins
+ - `:PlugUpdate` to install or update the plugins
+ - `:PlugDiff` to review the changes from the last update
 
->> Windows (PowerShell)~
->
-    iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
-        ni $HOME/vimfiles/autoload/plug.vim -Force
-<
+[!NOTE] That's basically all you need to know to get started. The rest of the
+document is for advanced users who want to know more about the features and
+options.
 
-Neovim~
-                                                                   *plug-neovim*
-
-
->> Unix~
->
-    sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
-           https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
-<
-
->> Windows (PowerShell)~
->
-    iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
-        ni "$(@($env:XDG_DATA_HOME, $env:LOCALAPPDATA)[$null -eq $env:XDG_DATA_HOME])/nvim-data/site/autoload/plug.vim" -Force
-<
 
 < Getting Help >______________________________________________________________~
                                                              *plug-getting-help*
 
- - See {tutorial}{6} page to learn the basics of vim-plug
- - See {tips}{7} and {FAQ}{8} pages for common problems and questions
- - See {requirements}{9} page for debugging information & tested configurations
- - Create an {issue}{10}
+ - See {tutorial}{4} page to learn more about the basics of vim-plug
+ - See {tips}{5} and {FAQ}{6} pages for common problems and questions
 
-                    {6} https://github.com/junegunn/vim-plug/wiki/tutorial
-                    {7} https://github.com/junegunn/vim-plug/wiki/tips
-                    {8} https://github.com/junegunn/vim-plug/wiki/faq
-                    {9} https://github.com/junegunn/vim-plug/wiki/requirements
-                    {10} https://github.com/junegunn/vim-plug/issues/new
+                        {4} https://github.com/junegunn/vim-plug/wiki/tutorial
+                        {5} https://github.com/junegunn/vim-plug/wiki/tips
+                        {6} https://github.com/junegunn/vim-plug/wiki/faq
 
 
-< Usage >_____________________________________________________________________~
-                                                                    *plug-usage*
+EXAMPLES                                                         *plug-examples*
+==============================================================================
 
-Add a vim-plug section to your `~/.vimrc` (or `stdpath('config') . '/init.vim'` for
-Neovim)
-
-                                                           *plug#begin* *plug#end*
-
- 1. Begin the section with `call plug#begin([PLUGIN_DIR])`
- 2. List the plugins with `Plug` commands
- 3. `call plug#end()` to update 'runtimepath' and initialize plugin system
-   - Automatically executes `filetype plugin indent on` and `syntax enable`.
-     You can revert the settings after the call. e.g. `filetype indent off`,
-     `syntax off`, etc.
+The following examples demonstrate the additional features of vim-plug.
 
 
-Example~
-                                                                  *plug-example*
+< Vim script example >________________________________________________________~
+                                                       *plug-vim-script-example*
 >
     call plug#begin()
     " The default plugin directory will be as follows:
@@ -143,65 +121,129 @@ Example~
 
     " Make sure you use single quotes
 
-    " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
-    Plug 'junegunn/vim-easy-align'
+    " Shorthand notation for GitHub; translates to https://github.com/junegunn/seoul256.vim.git
+    Plug 'junegunn/seoul256.vim'
 
     " Any valid git URL is allowed
-    Plug 'https://github.com/junegunn/vim-github-dashboard.git'
-
-    " Multiple Plug commands can be written in a single line using | separators
-    Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
-
-    " On-demand loading
-    Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
-    Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
-
-    " Using a non-default branch
-    Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
+    Plug 'https://github.com/junegunn/vim-easy-align.git'
 
     " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
     Plug 'fatih/vim-go', { 'tag': '*' }
 
-    " Plugin options
-    Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
+    " Using a non-default branch
+    Plug 'neoclide/coc.nvim', { 'branch': 'release' }
 
-    " Plugin outside ~/.vim/plugged with post-update hook
+    " Use 'dir' option to install plugin in a non-default directory
+    Plug 'junegunn/fzf', { 'dir': '~/.fzf' }
+
+    " Post-update hook: run a shell command after installing or updating the plugin
     Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 
+    " Post-update hook can be a lambda expression
+    Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+
+    " If the vim plugin is in a subdirectory, use 'rtp' option to specify its path
+    Plug 'nsf/gocode', { 'rtp': 'vim' }
+
+    " On-demand loading: loaded when the specified command is executed
+    Plug 'preservim/nerdtree', { 'on': 'NERDTreeToggle' }
+
+    " On-demand loading: loaded when a file with a specific file type is opened
+    Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
+
     " Unmanaged plugin (manually installed and updated)
     Plug '~/my-prototype-plugin'
 
-    " Initialize plugin system
+    " Call plug#end to update &runtimepath and initialize the plugin system.
+    " - It automatically executes `filetype plugin indent on` and `syntax enable`
     call plug#end()
+    " You can revert the settings after the call like so:
+    "   filetype indent off   " Disable file-type-specific indentation
+    "   syntax off            " Disable syntax highlighting
+
+    " Color schemes should be loaded after plug#end().
+    " We prepend it with 'silent!' to ignore errors when it's not yet installed.
+    silent! colorscheme seoul256
 <
-                                                                  *:PlugInstall*
 
-Reload .vimrc and `:PlugInstall` to install plugins.
+< Lua example for Neovim >____________________________________________________~
+                                                   *plug-lua-example-for-neovim*
 
+In Neovim, you can write your configuration in a Lua script file named
+`init.lua`. The following code is the Lua script equivalent to the Vim script
+example above.
+>
+    local vim = vim
+    local Plug = vim.fn['plug#']
 
-< Commands >__________________________________________________________________~
-                                                                 *plug-commands*
+    vim.call('plug#begin')
 
- ------------------------------------+-------------------------------------------------------------------
- Command                             | Description                                                       ~
- ------------------------------------+-------------------------------------------------------------------
-  `PlugInstall [name ...] [#threads]`  | Install plugins
-  `PlugUpdate [name ...] [#threads]`   | Install or update plugins
+    -- Shorthand notation for GitHub; translates to https://github.com/junegunn/seoul256.vim.git
+    Plug('junegunn/seoul256.vim')
+
+    -- Any valid git URL is allowed
+    Plug('https://github.com/junegunn/vim-easy-align.git')
+
+    -- Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
+    Plug('fatih/vim-go', { ['tag'] = '*' })
+
+    -- Using a non-default branch
+    Plug('neoclide/coc.nvim', { ['branch'] = 'release' })
+
+    -- Use 'dir' option to install plugin in a non-default directory
+    Plug('junegunn/fzf', { ['dir'] = '~/.fzf' })
+
+    -- Post-update hook: run a shell command after installing or updating the plugin
+    Plug('junegunn/fzf', { ['dir'] = '~/.fzf', ['do'] = './install --all' })
+
+    -- Post-update hook can be a lambda expression
+    Plug('junegunn/fzf', { ['do'] = function()
+      vim.fn['fzf#install']()
+    end })
+
+    -- If the vim plugin is in a subdirectory, use 'rtp' option to specify its path
+    Plug('nsf/gocode', { ['rtp'] = 'vim' })
+
+    -- On-demand loading: loaded when the specified command is executed
+    Plug('preservim/nerdtree', { ['on'] = 'NERDTreeToggle' })
+
+    -- On-demand loading: loaded when a file with a specific file type is opened
+    Plug('tpope/vim-fireplace', { ['for'] = 'clojure' })
+
+    -- Unmanaged plugin (manually installed and updated)
+    Plug('~/my-prototype-plugin')
+
+    vim.call('plug#end')
+
+    -- Color schemes should be loaded after plug#end().
+    -- We prepend it with 'silent!' to ignore errors when it's not yet installed.
+    vim.cmd('silent! colorscheme seoul256')
+<
+
+COMMANDS                                                         *plug-commands*
+==============================================================================
+
+ -------------------------------------+------------------------------------------------------------------
+ Command                              | Description                                                      ~
+ -------------------------------------+------------------------------------------------------------------
+  `PlugInstall [name ...] [#threads]`  | Install plugins
+  `PlugUpdate [name ...] [#threads]`   | Install or update plugins
   `PlugClean[!]`                       | Remove unlisted plugins (bang version will clean without prompt)
   `PlugUpgrade`                        | Upgrade vim-plug itself
   `PlugStatus`                         | Check the status of plugins
   `PlugDiff`                           | Examine changes from the previous update and the pending changes
-  `PlugSnapshot[!] [output path]`      | Generate script for restoring the current snapshot of the plugins
- ------------------------------------+-------------------------------------------------------------------
+  `PlugSnapshot[!] [output path]`      | Generate script for restoring the current snapshot of the plugins
+ -------------------------------------+------------------------------------------------------------------
 
 
-< Plug options >______________________________________________________________~
-                                                                  *plug-options*
-                                                                         *:Plug*
+PLUG OPTIONS                                                      *plug-options*
+==============================================================================
 
- ------------------------+-----------------------------------------------
- Option                  | Description                                   ~
- ------------------------+-----------------------------------------------
+                                                               *<Plug>-mappings*
+
+ ------------------------+------------------------------------------------------------
+ Option                  | Description                                                ~
+ ------------------------+------------------------------------------------------------
   `branch` / `tag` / `commit`  | Branch/tag/commit of the repository to use
   `rtp`                    | Subdirectory that contains Vim plugin
   `dir`                    | Custom directory for the plugin
@@ -209,12 +251,12 @@ Reload .vimrc and `:PlugInstall` to install plugins.
   `do`                     | Post-update hook (string or funcref)
   `on`                     | On-demand loading: Commands or <Plug>-mappings
   `for`                    | On-demand loading: File types
-  `frozen`                 | Do not update unless explicitly specified
- ------------------------+-----------------------------------------------
+  `frozen`                 | Do not remove and do not update unless explicitly specified
+ ------------------------+------------------------------------------------------------
 
 
-< Global options >____________________________________________________________~
-                                                           *plug-global-options*
+GLOBAL OPTIONS                                             *plug-global-options*
+==============================================================================
 
      *g:plug_threads* *g:plug_timeout* *g:plug_retries* *g:plug_shallow* *g:plug_window*
                                               *g:plug_pwindow* *g:plug_url_format*
@@ -226,16 +268,14 @@ Reload .vimrc and `:PlugInstall` to install plugins.
   `g:plug_timeout`     | 60                                | Time limit of each task in seconds (Ruby & Python)
   `g:plug_retries`     | 2                                 | Number of retries in case of timeout (Ruby & Python)
   `g:plug_shallow`     | 1                                 | Use shallow clone
-  `g:plug_window`      |  `vertical topleft new`             | Command to open plug window
-  `g:plug_pwindow`     |  `above 12new`                      | Command to open preview window in  `PlugDiff`
+  `g:plug_window`      |  `-tabnew`                          | Command to open plug window
+  `g:plug_pwindow`     |  `vertical rightbelow new`          | Command to open preview window in  `PlugDiff`
   `g:plug_url_format`  |  `https://git::@github.com/%s.git`  |  `printf`  format to build repo URL (Only applies to the subsequent  `Plug`  commands)
  --------------------+-----------------------------------+-----------------------------------------------------------------------------------
 
 
-< Keybindings >_______________________________________________________________~
-                                                              *plug-keybindings*
-
-                                                         *:PlugStatus* *:PlugDiff*
+KEYBINDINGS                                                   *plug-keybindings*
+==============================================================================
 
  - `D` - `PlugDiff`
  - `S` - `PlugStatus`
@@ -248,19 +288,75 @@ Reload .vimrc and `:PlugInstall` to install plugins.
    - `X` - Revert the update
 
 
-< Example: A small sensible Vim configuration >_______________________________~
-                               *plug-example-a-small-sensible-vim-configuration*
+POST-UPDATE HOOKS                                       *plug-post-update-hooks*
+==============================================================================
+
+There are some plugins that require extra steps after installation or update.
+In that case, use the `do` option to describe the task to be performed.
 >
-    call plug#begin()
-    Plug 'tpope/vim-sensible'
-    call plug#end()
+    Plug 'Shougo/vimproc.vim', { 'do': 'make' }
+    Plug 'ycm-core/YouCompleteMe', { 'do': './install.py' }
+<
+If the value starts with `:`, it will be recognized as a Vim command.
+>
+    Plug 'fatih/vim-go', { 'do': ':GoInstallBinaries' }
+<
+To call a Vim function, you can pass a lambda expression like so:
+>
+    Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+<
+If you need more control, you can pass a reference to a Vim function that
+takes a dictionary argument.
+>
+    function! BuildYCM(info)
+      " info is a dictionary with 3 fields
+      " - name:   name of the plugin
+      " - status: 'installed', 'updated', or 'unchanged'
+      " - force:  set on PlugInstall! or PlugUpdate!
+      if a:info.status == 'installed' || a:info.force
+        !./install.py
+      endif
+    endfunction
+
+    Plug 'ycm-core/YouCompleteMe', { 'do': function('BuildYCM') }
+<
+A post-update hook is executed inside the directory of the plugin and only run
+when the repository has changed, but you can force it to run unconditionally
+with the bang-versions of the commands: `PlugInstall!` and `PlugUpdate!`.
+
+[!TIP] Make sure to escape BARs and double-quotes when you write the `do`
+option inline as they are mistakenly recognized as command separator or the
+start of the trailing comment.
+>
+    Plug 'junegunn/fzf', { 'do': 'yes \| ./install' }
+<
+But you can avoid the escaping if you extract the inline specification using a
+variable (or any Vim script expression) as follows:
+>
+    let g:fzf_install = 'yes | ./install'
+    Plug 'junegunn/fzf', { 'do': g:fzf_install }
 <
 
-< On-demand loading of plugins >______________________________________________~
-                                             *plug-on-demand-loading-of-plugins*
+< PlugInstall! and PlugUpdate! >______________________________________________~
+                                                    *pluginstall-and-plugupdate*
+
+The installer takes the following steps when installing/updating a plugin:
+
+ 1. `git clone` or `git fetch` from its origin
+ 2. Check out branch, tag, or commit and optionally `git merge` remote branch
+ 3. If the plugin was updated (or installed for the first time)
+   1. Update submodules
+   2. Execute post-update hooks
+
+The commands with the `!` suffix ensure that all steps are run
+unconditionally.
+
+
+ON-DEMAND LOADING OF PLUGINS                 *plug-on-demand-loading-of-plugins*
+==============================================================================
 >
     " NERD tree will be loaded on the first invocation of NERDTreeToggle command
-    Plug 'scrooloose/nerdtree', { 'on': 'NERDTreeToggle' }
+    Plug 'preservim/nerdtree', { 'on': 'NERDTreeToggle' }
 
     " Multiple commands
     Plug 'junegunn/vim-github-dashboard', { 'on': ['GHDashboard', 'GHActivity'] }
@@ -278,104 +374,55 @@ Reload .vimrc and `:PlugInstall` to install plugins.
     Plug 'junegunn/goyo.vim', { 'for': 'markdown' }
     autocmd! User goyo.vim echom 'Goyo is now loaded!'
 <
-The `for` option is generally not needed as most plugins for specific file
-types usually don't have too much code in the `plugin` directory. You might
-want to examine the output of `vim --startuptime` before applying the option.
+[!NOTE] #### Should I set up on-demand loading?
 
+You probably don't need to.
 
-< Post-update hooks >_________________________________________________________~
-                                                        *plug-post-update-hooks*
+A properly implemented Vim plugin should already load lazily without any help
+from a plugin manager (`:help autoload`). So there are few cases where these
+options actually make much sense. Making a plugin load faster is the
+responsibility of the plugin developer, not the user. If you find a plugin
+that takes too long to load, consider opening an issue on the plugin's issue
+tracker.
 
-There are some plugins that require extra steps after installation or update.
-In that case, use the `do` option to describe the task to be performed.
+Let me give you a perspective. The time it takes to load a plugin is usually
+less than 2 or 3ms on modern computers. So unless you use a very large number
+of plugins, you are unlikely to save more than 50ms. If you have spent an hour
+carefully setting up the options to shave off 50ms, you will have to start Vim
+72,000 times just to break even. You should ask yourself if that's a good
+investment of your time.
+
+Make sure that you're tackling the right problem by breaking down the startup
+time of Vim using `--startuptime`.
 >
-    Plug 'Shougo/vimproc.vim', { 'do': 'make' }
-    Plug 'ycm-core/YouCompleteMe', { 'do': './install.py' }
+    vim --startuptime /tmp/log
 <
-If the value starts with `:`, it will be recognized as a Vim command.
+On-demand loading should only be used as a last resort. It is basically a
+hacky workaround and is not always guaranteed to work.
 
-                                                            *:GoInstallBinaries*
->
-    Plug 'fatih/vim-go', { 'do': ':GoInstallBinaries' }
-<
-If you need more control, you can pass a reference to a Vim function that
-takes a single argument.
->
-    function! BuildYCM(info)
-      " info is a dictionary with 3 fields
-      " - name:   name of the plugin
-      " - status: 'installed', 'updated', or 'unchanged'
-      " - force:  set on PlugInstall! or PlugUpdate!
-      if a:info.status == 'installed' || a:info.force
-        !./install.py
-      endif
-    endfunction
+                                                                     *plug#load*
 
-    Plug 'ycm-core/YouCompleteMe', { 'do': function('BuildYCM') }
-<
-Both forms of post-update hook are executed inside the directory of the plugin
-and only run when the repository has changed, but you can force it to run
-unconditionally with the bang-versions of the commands: `PlugInstall!` and
-`PlugUpdate!`.
+[!TIP] You can pass an empty list to `on` or `for` option to disable the
+loading of the plugin. You can manually load the plugin using
+`plug#load(NAMES...)` function.
 
-Make sure to escape BARs and double-quotes when you write the `do` option
-inline as they are mistakenly recognized as command separator or the start of
-the trailing comment.
->
-    Plug 'junegunn/fzf', { 'do': 'yes \| ./install' }
-<
-But you can avoid the escaping if you extract the inline specification using a
-variable (or any Vimscript expression) as follows:
-
-                                                                 *g:fzf_install*
->
-    let g:fzf_install = 'yes | ./install'
-    Plug 'junegunn/fzf', { 'do': g:fzf_install }
-<
-
-< PlugInstall! and PlugUpdate! >______________________________________________~
-                                                    *pluginstall-and-plugupdate*
-
-The installer takes the following steps when installing/updating a plugin:
-
- 1. `git clone` or `git fetch` from its origin
- 2. Check out branch, tag, or commit and optionally `git merge` remote branch
- 3. If the plugin was updated (or installed for the first time)
-   1. Update submodules
-   2. Execute post-update hooks
-
-The commands with the `!` suffix ensure that all steps are run
-unconditionally.
+See https://github.com/junegunn/vim-plug/wiki/tips#loading-plugins-manually
 
 
-< Articles >__________________________________________________________________~
-                                                                 *plug-articles*
+COLLABORATORS                                               *plug-collaborators*
+==============================================================================
 
- - {Writing my own Vim plugin manager}{11}
- - {Vim plugins and startup time}{12}
- - ~~{Thoughts on Vim plugin dependency}{13}~~
-   - Support for Plugfile has been removed since 0.5.0
+ - {Jan Edmund Lazo}{7} - Windows support
+ - {Jeremy Pallats}{8} - Python installer
 
-             {11} http://junegunn.kr/2013/09/writing-my-own-vim-plugin-manager
-             {12} http://junegunn.kr/2014/07/vim-plugins-and-startup-time
-             {13} http://junegunn.kr/2013/09/thoughts-on-vim-plugin-dependency
+                                           {7} https://github.com/janlazo
+                                           {8} https://github.com/starcraftman
 
 
-< Collaborators >_____________________________________________________________~
-                                                            *plug-collaborators*
-
- - {Jan Edmund Lazo}{14} - Windows support
- - {Jeremy Pallats}{15} - Python installer
-
-                                          {14} https://github.com/janlazo
-                                          {15} https://github.com/starcraftman
-
-
-< License >___________________________________________________________________~
-                                                                  *plug-license*
+LICENSE                                                           *plug-license*
+==============================================================================
 
 MIT
 
-
 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

plug.vim

@@ -1,67 +1,36 @@
 " vim-plug: Vim plugin manager
 " ============================
 "
-" Download plug.vim and put it in ~/.vim/autoload
+" 1. Download plug.vim and put it in 'autoload' directory
 "
+"   # Vim
 "   curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
 "     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
 "
-" Edit your .vimrc
+"   # Neovim
+"   sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
+"     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
 "
-"   call plug#begin('~/.vim/plugged')
+" 2. Add a vim-plug section to your ~/.vimrc (or ~/.config/nvim/init.vim for Neovim)
 "
-"   " Make sure you use single quotes
+"   call plug#begin()
 "
-"   " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
-"   Plug 'junegunn/vim-easy-align'
+"   " List your plugins here
+"   Plug 'tpope/vim-sensible'
 "
-"   " Any valid git URL is allowed
-"   Plug 'https://github.com/junegunn/vim-github-dashboard.git'
-"
-"   " Multiple Plug commands can be written in a single line using | separators
-"   Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
-"
-"   " On-demand loading
-"   Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
-"   Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
-"
-"   " Using a non-default branch
-"   Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
-"
-"   " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
-"   Plug 'fatih/vim-go', { 'tag': '*' }
-"
-"   " Plugin options
-"   Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
-"
-"   " Plugin outside ~/.vim/plugged with post-update hook
-"   Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
-"
-"   " Unmanaged plugin (manually installed and updated)
-"   Plug '~/my-prototype-plugin'
-"
-"   " Initialize plugin system
 "   call plug#end()
 "
-" Then reload .vimrc and :PlugInstall to install plugins.
+" 3. Reload the file or restart Vim, then you can,
 "
-" Plug options:
+"     :PlugInstall to install plugins
+"     :PlugUpdate  to update plugins
+"     :PlugDiff    to review the changes from the last update
+"     :PlugClean   to remove plugins no longer in the list
 "
-"| Option                  | Description                                      |
-"| ----------------------- | ------------------------------------------------ |
-"| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use       |
-"| `rtp`                   | Subdirectory that contains Vim plugin            |
-"| `dir`                   | Custom directory for the plugin                  |
-"| `as`                    | Use different name for the plugin                |
-"| `do`                    | Post-update hook (string or funcref)             |
-"| `on`                    | On-demand loading: Commands or `<Plug>`-mappings |
-"| `for`                   | On-demand loading: File types                    |
-"| `frozen`                | Do not update unless explicitly specified        |
-"
-" More information: https://github.com/junegunn/vim-plug
+" For more information, see https://github.com/junegunn/vim-plug
 "
 "
-" Copyright (c) 2017 Junegunn Choi
+" Copyright (c) 2024 Junegunn Choi
 "
 " MIT License
 "
@@ -115,6 +84,9 @@ let s:TYPE = {
 \ }
 let s:loaded = get(s:, 'loaded', {})
 let s:triggers = get(s:, 'triggers', {})
+let s:need_filetypeplugin_au = 0
+let s:need_filetypeindent_au = 0
+let s:autocmd_queue_for_vimenter = []
 
 function! s:is_powershell(shell)
   return a:shell =~# 'powershell\(\.exe\)\?$' || a:shell =~# 'pwsh\(\.exe\)\?$'
@@ -238,7 +210,6 @@ endfunction
 
 function! plug#begin(...)
   if a:0 > 0
-    let s:plug_home_org = a:1
     let home = s:path(s:plug_fnamemodify(s:plug_expand(a:1), ':p'))
   elseif exists('g:plug_home')
     let home = s:path(g:plug_home)
@@ -352,9 +323,24 @@ function! plug#end()
   endif
   let lod = { 'ft': {}, 'map': {}, 'cmd': {} }
 
-  if exists('g:did_load_filetypes')
+  if get(g:, 'did_load_filetypes', 0)
     filetype off
   endif
+
+  let warn = []
+  if exists('g:did_load_ftplugin')
+    let warn += ['plugin']
+    let s:need_filetypeindent_au = 1
+  endif
+  if exists('g:did_indent_on')
+    let warn += ['indent']
+    let s:need_filetypeplugin_au = 1
+  endif
+  if !empty(warn)
+    redraw
+    call s:warn('echom', printf('[vim-plug] "filetype %s on" should not be used manually with vim-plug, please remove it from your vimrc.', join(warn)))
+  endif
+
   for name in g:plugs_order
     if !has_key(g:plugs, name)
       continue
@@ -391,6 +377,9 @@ function! plug#end()
       if !empty(types)
         augroup filetypedetect
         call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim')
+        if has('nvim-0.5.0')
+          call s:source(s:rtp(plug), 'ftdetect/**/*.lua', 'after/ftdetect/**/*.lua')
+        endif
         augroup END
       endif
       for type in types
@@ -427,7 +416,21 @@ function! plug#end()
     if has('syntax') && !exists('g:syntax_on')
       syntax enable
     end
+
+    " NOTE: v:vim_did_enter might not exist with older Vims, and handling it
+    " manually can be used in tests.
+    let s:vim_did_enter = 0
+    function! s:plug_on_vimenter()
+      let s:vim_did_enter = 1
+      for event in s:autocmd_queue_for_vimenter
+        call s:doautocmd(event)
+      endfor
+    endfunction
+    augroup PlugLOD
+      autocmd VimEnter * call s:plug_on_vimenter()
+    augroup END
   else
+    let s:vim_did_enter = 1
     call s:reload_plugins()
   endif
 endfunction
@@ -438,6 +441,9 @@ endfunction
 
 function! s:load_plugin(spec)
   call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim')
+  if has('nvim-0.5.0')
+    call s:source(s:rtp(a:spec), 'plugin/**/*.lua', 'after/plugin/**/*.lua')
+  endif
 endfunction
 
 function! s:reload_plugins()
@@ -587,6 +593,12 @@ function! s:reorg_rtp()
 endfunction
 
 function! s:doautocmd(...)
+  if !s:vim_did_enter
+    if index(s:autocmd_queue_for_vimenter, a:000) == -1
+      call add(s:autocmd_queue_for_vimenter, a:000)
+    endif
+    return
+  endif
   if exists('#'.join(a:000, '#'))
     execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000)
   endif
@@ -597,9 +609,7 @@ function! s:dobufread(names)
     let path = s:rtp(g:plugs[name])
     for dir in ['ftdetect', 'ftplugin', 'after/ftdetect', 'after/ftplugin']
       if len(finddir(dir, path))
-        if exists('#BufRead')
-          doautocmd BufRead
-        endif
+        call s:doautocmd('BufRead')
         return
       endif
     endfor
@@ -655,6 +665,9 @@ function! s:lod(names, types, ...)
     let rtp = s:rtp(g:plugs[name])
     for dir in a:types
       call s:source(rtp, dir.'/**/*.vim')
+      if has('nvim-0.5.0')  " see neovim#14686
+        call s:source(rtp, dir.'/**/*.lua')
+      endif
     endfor
     if a:0
       if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2))
@@ -670,8 +683,17 @@ function! s:lod_ft(pat, names)
   let syn = 'syntax/'.a:pat.'.vim'
   call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn)
   execute 'autocmd! PlugLOD FileType' a:pat
-  call s:doautocmd('filetypeplugin', 'FileType')
-  call s:doautocmd('filetypeindent', 'FileType')
+
+  " Executing this is only necessary if "filetype plugin indent on" was used
+  " before plug#end, and can be skipped when Vim has not entered always.
+  if s:vim_did_enter
+    if s:need_filetypeplugin_au
+      call s:doautocmd('filetypeplugin', 'FileType')
+    endif
+    if s:need_filetypeindent_au
+      call s:doautocmd('filetypeindent', 'FileType')
+    endif
+  endif
 endfunction
 
 function! s:lod_cmd(cmd, bang, l1, l2, args, names)
@@ -869,7 +891,7 @@ function! s:lastline(msg)
 endfunction
 
 function! s:new_window()
-  execute get(g:, 'plug_window', 'vertical topleft new')
+  execute get(g:, 'plug_window', '-tabnew')
 endfunction
 
 function! s:plug_window_exists()
@@ -1031,6 +1053,11 @@ function! s:is_updated(dir)
 endfunction
 
 function! s:do(pull, force, todo)
+  if has('nvim')
+    " Reset &rtp to invalidate Neovim cache of loaded Lua modules
+    " See https://github.com/junegunn/vim-plug/pull/1157#issuecomment-1809226110
+    let &rtp = &rtp
+  endif
   for [name, spec] in items(a:todo)
     if !isdirectory(spec.dir)
       continue
@@ -1092,12 +1119,14 @@ endfunction
 function! s:checkout(spec)
   let sha = a:spec.commit
   let output = s:git_revision(a:spec.dir)
+  let error = 0
   if !empty(output) && !s:hash_match(sha, s:lines(output)[0])
     let credential_helper = s:git_version_requirement(2) ? '-c credential.helper= ' : ''
     let output = s:system(
           \ 'git '.credential_helper.'fetch --depth 999999 && git checkout '.plug#shellescape(sha).' --', a:spec.dir)
+    let error = v:shell_error
   endif
-  return output
+  return [output, error]
 endfunction
 
 function! s:finish(pull)
@@ -1158,7 +1187,7 @@ function! s:update_impl(pull, force, args) abort
   let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?
                   \ remove(args, -1) : get(g:, 'plug_threads', 16)
 
-  let managed = filter(copy(g:plugs), 's:is_managed(v:key)')
+  let managed = filter(deepcopy(g:plugs), 's:is_managed(v:key)')
   let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :
                          \ filter(managed, 'index(args, v:key) >= 0')
 
@@ -1292,9 +1321,11 @@ function! s:update_finish()
       if !pos
         continue
       endif
+      let out = ''
+      let error = 0
       if has_key(spec, 'commit')
         call s:log4(name, 'Checking out '.spec.commit)
-        let out = s:checkout(spec)
+        let [out, error] = s:checkout(spec)
       elseif has_key(spec, 'tag')
         let tag = spec.tag
         if tag =~ '\*'
@@ -1307,19 +1338,16 @@ function! s:update_finish()
         endif
         call s:log4(name, 'Checking out '.tag)
         let out = s:system('git checkout -q '.plug#shellescape(tag).' -- 2>&1', spec.dir)
-      else
-        let branch = s:git_origin_branch(spec)
-        call s:log4(name, 'Merging origin/'.s:esc(branch))
-        let out = s:system('git checkout -q '.plug#shellescape(branch).' -- 2>&1'
-              \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only '.plug#shellescape('origin/'.branch).' 2>&1')), spec.dir)
+        let error = v:shell_error
       endif
-      if !v:shell_error && filereadable(spec.dir.'/.gitmodules') &&
+      if !error && filereadable(spec.dir.'/.gitmodules') &&
             \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir))
         call s:log4(name, 'Updating submodules. This may take a while.')
         let out .= s:bang('git submodule update --init --recursive'.s:submodule_opt.' 2>&1', spec.dir)
+        let error = v:shell_error
       endif
       let msg = s:format_message(v:shell_error ? 'x': '-', name, out)
-      if v:shell_error
+      if error
         call add(s:update.errors, name)
         call s:regress_bar()
         silent execute pos 'd _'
@@ -1382,7 +1410,9 @@ function! s:job_out_cb(self, data) abort
   if !self.running || self.tick % len(s:jobs) == 0
     let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-')
     let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines)
-    call s:log(bullet, self.name, result)
+    if len(result)
+      call s:log(bullet, self.name, result)
+    endif
   endif
 endfunction
 
@@ -1406,16 +1436,17 @@ function! s:nvim_cb(job_id, data, event) dict abort
     \ s:job_cb('s:job_exit_cb', self, 0, a:data)
 endfunction
 
-function! s:spawn(name, cmd, opts)
-  let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''],
-            \ 'new': get(a:opts, 'new', 0) }
+function! s:spawn(name, spec, queue, opts)
+  let job = { 'name': a:name, 'spec': a:spec, 'running': 1, 'error': 0, 'lines': [''],
+            \ 'new': get(a:opts, 'new', 0), 'queue': copy(a:queue) }
+  let Item = remove(job.queue, 0)
+  let argv = type(Item) == s:TYPE.funcref ? call(Item, [a:spec]) : Item
   let s:jobs[a:name] = job
 
   if s:nvim
     if has_key(a:opts, 'dir')
       let job.cwd = a:opts.dir
     endif
-    let argv = a:cmd
     call extend(job, {
     \ 'on_stdout': function('s:nvim_cb'),
     \ 'on_stderr': function('s:nvim_cb'),
@@ -1431,7 +1462,7 @@ function! s:spawn(name, cmd, opts)
             \ 'Invalid arguments (or job table is full)']
     endif
   elseif s:vim8
-    let cmd = join(map(copy(a:cmd), 'plug#shellescape(v:val, {"script": 0})'))
+    let cmd = join(map(copy(argv), 'plug#shellescape(v:val, {"script": 0})'))
     if has_key(a:opts, 'dir')
       let cmd = s:with_cd(cmd, a:opts.dir, 0)
     endif
@@ -1451,27 +1482,34 @@ function! s:spawn(name, cmd, opts)
       let job.lines   = ['Failed to start job']
     endif
   else
-    let job.lines = s:lines(call('s:system', has_key(a:opts, 'dir') ? [a:cmd, a:opts.dir] : [a:cmd]))
+    let job.lines = s:lines(call('s:system', has_key(a:opts, 'dir') ? [argv, a:opts.dir] : [argv]))
     let job.error = v:shell_error != 0
     let job.running = 0
   endif
 endfunction
 
 function! s:reap(name)
-  let job = s:jobs[a:name]
+  let job = remove(s:jobs, a:name)
   if job.error
     call add(s:update.errors, a:name)
   elseif get(job, 'new', 0)
     let s:update.new[a:name] = 1
   endif
-  let s:update.bar .= job.error ? 'x' : '='
 
-  let bullet = job.error ? 'x' : '-'
+  let more = len(get(job, 'queue', []))
+  let bullet = job.error ? 'x' : more ? (job.new ? '+' : '*') : '-'
   let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines)
-  call s:log(bullet, a:name, empty(result) ? 'OK' : result)
-  call s:bar()
+  if len(result)
+    call s:log(bullet, a:name, result)
+  endif
 
-  call remove(s:jobs, a:name)
+  if !job.error && more
+    let job.spec.queue = job.queue
+    let s:update.todo[a:name] = job.spec
+  else
+    let s:update.bar .= job.error ? 'x' : '='
+    call s:bar()
+  endif
 endfunction
 
 function! s:bar()
@@ -1524,6 +1562,16 @@ function! s:update_vim()
   call s:tick()
 endfunction
 
+function! s:checkout_command(spec)
+  let a:spec.branch = s:git_origin_branch(a:spec)
+  return ['git', 'checkout', '-q', a:spec.branch, '--']
+endfunction
+
+function! s:merge_command(spec)
+  let a:spec.branch = s:git_origin_branch(a:spec)
+  return ['git', 'merge', '--ff-only', 'origin/'.a:spec.branch]
+endfunction
+
 function! s:tick()
   let pull = s:update.pull
   let prog = s:progress_opt(s:nvim || s:vim8)
@@ -1538,13 +1586,18 @@ while 1 " Without TCO, Vim stack is bound to explode
 
   let name = keys(s:update.todo)[0]
   let spec = remove(s:update.todo, name)
-  let new  = empty(globpath(spec.dir, '.git', 1))
+  let queue = get(spec, 'queue', [])
+  let new = empty(globpath(spec.dir, '.git', 1))
 
-  call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
-  redraw
+  if empty(queue)
+    call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
+    redraw
+  endif
 
   let has_tag = has_key(spec, 'tag')
-  if !new
+  if len(queue)
+    call s:spawn(name, spec, queue, { 'dir': spec.dir })
+  elseif !new
     let [error, _] = s:git_validate(spec, 0)
     if empty(error)
       if pull
@@ -1555,7 +1608,11 @@ while 1 " Without TCO, Vim stack is bound to explode
         if !empty(prog)
           call add(cmd, prog)
         endif
-        call s:spawn(name, cmd, { 'dir': spec.dir })
+        let queue = [cmd, split('git remote set-head origin -a')]
+        if !has_tag && !has_key(spec, 'commit')
+          call extend(queue, [function('s:checkout_command'), function('s:merge_command')])
+        endif
+        call s:spawn(name, spec, queue, { 'dir': spec.dir })
       else
         let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 }
       endif
@@ -1570,7 +1627,7 @@ while 1 " Without TCO, Vim stack is bound to explode
     if !empty(prog)
       call add(cmd, prog)
     endif
-    call s:spawn(name, extend(cmd, [spec.uri, s:trim(spec.dir)]), { 'new': 1 })
+    call s:spawn(name, spec, [extend(cmd, [spec.uri, s:trim(spec.dir)]), function('s:checkout_command'), function('s:merge_command')], { 'new': 1 })
   endif
 
   if !s:jobs[name].running
@@ -2269,7 +2326,10 @@ endfunction
 
 function! s:with_cd(cmd, dir, ...)
   let script = a:0 > 0 ? a:1 : 1
-  return printf('cd%s %s && %s', s:is_win ? ' /d' : '', plug#shellescape(a:dir, {'script': script}), a:cmd)
+  let pwsh = s:is_powershell(&shell)
+  let cd = s:is_win && !pwsh ? 'cd /d' : 'cd'
+  let sep = pwsh ? ';' : '&&'
+  return printf('%s %s %s %s', cd, plug#shellescape(a:dir, {'script': script, 'shell': &shell}), sep, a:cmd)
 endfunction
 
 function! s:system(cmd, ...)
@@ -2346,18 +2406,21 @@ function! s:git_validate(spec, check_branch)
               \ current_branch, origin_branch)
       endif
       if empty(err)
-        let [ahead, behind] = split(s:lastline(s:system([
-        \ 'git', 'rev-list', '--count', '--left-right',
-        \ printf('HEAD...origin/%s', origin_branch)
-        \ ], a:spec.dir)), '\t')
-        if !v:shell_error && ahead
-          if behind
+        let ahead_behind = split(s:lastline(s:system([
+          \ 'git', 'rev-list', '--count', '--left-right',
+          \ printf('HEAD...origin/%s', origin_branch)
+          \ ], a:spec.dir)), '\t')
+        if v:shell_error || len(ahead_behind) != 2
+          let err = "Failed to compare with the origin. The default branch might have changed.\nPlugClean required."
+        else
+          let [ahead, behind] = ahead_behind
+          if ahead && behind
             " Only mention PlugClean if diverged, otherwise it's likely to be
             " pushable (and probably not that messed up).
             let err = printf(
                   \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n"
                   \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', origin_branch, ahead, behind)
-          else
+          elseif ahead
             let err = printf("Ahead of origin/%s by %d commit(s).\n"
                   \ .'Cannot update until local changes are pushed.',
                   \ origin_branch, ahead)
@@ -2389,7 +2452,7 @@ function! s:clean(force)
   let errs = {}
   let [cnt, total] = [0, len(g:plugs)]
   for [name, spec] in items(g:plugs)
-    if !s:is_managed(name)
+    if !s:is_managed(name) || get(spec, 'frozen', 0)
       call add(dirs, spec.dir)
     else
       let [err, clean] = s:git_validate(spec, 1)
@@ -2621,26 +2684,34 @@ function! s:preview_commit()
 
   let sha = matchstr(getline('.'), '^  \X*\zs[0-9a-f]\{7,9}')
   if empty(sha)
-    return
+    let name = matchstr(getline('.'), '^- \zs[^:]*\ze:$')
+    if empty(name)
+      return
+    endif
+    let title = 'HEAD@{1}..'
+    let command = 'git diff --no-color HEAD@{1}'
+  else
+    let title = sha
+    let command = 'git show --no-color --pretty=medium '.sha
+    let name = s:find_name(line('.'))
   endif
 
-  let name = s:find_name(line('.'))
   if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir)
     return
   endif
 
-  if exists('g:plug_pwindow') && !s:is_preview_window_open()
-    execute g:plug_pwindow
-    execute 'e' sha
+  if !s:is_preview_window_open()
+    execute get(g:, 'plug_pwindow', 'vertical rightbelow new')
+    execute 'e' title
   else
-    execute 'pedit' sha
+    execute 'pedit' title
     wincmd P
   endif
-  setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable
+  setlocal previewwindow filetype=git buftype=nofile bufhidden=wipe nobuflisted modifiable
   let batchfile = ''
   try
     let [sh, shellcmdflag, shrd] = s:chsh(1)
-    let cmd = 'cd '.plug#shellescape(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha
+    let cmd = 'cd '.plug#shellescape(g:plugs[name].dir).' && '.command
     if s:is_win
       let [batchfile, cmd] = s:batchfile(cmd)
     endif
@@ -2766,9 +2837,9 @@ function! s:snapshot(force, ...) abort
   1
   let anchor = line('$') - 3
   let names = sort(keys(filter(copy(g:plugs),
-        \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)')))
+        \'has_key(v:val, "uri") && isdirectory(v:val.dir)')))
   for name in reverse(names)
-    let sha = s:git_revision(g:plugs[name].dir)
+    let sha = has_key(g:plugs[name], 'commit') ? g:plugs[name].commit : s:git_revision(g:plugs[name].dir)
     if !empty(sha)
       call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha))
       redraw

test/regressions.vader

@@ -5,6 +5,10 @@ Execute (#112 On-demand loading should not suppress messages from ftplugin):
   Plug '$PLUG_FIXTURES/ftplugin-msg', { 'for': 'c' }
   call plug#end()
 
+  " Trigger VimEnter (simulate Vim being started), so that s:lod handles
+  " filetypeindent/filetypeplugin."
+  doautocmd VimEnter
+
   redir => out
   tabnew a.c
   redir END

test/run

@@ -62,7 +62,7 @@ EOF
 
 gitinit() (
   cd "$PLUG_FIXTURES/$1"
-  git init
+  git init -b master
   git commit -m 'commit' --allow-empty
 )
 
@@ -98,7 +98,7 @@ DOC
 
   rm -rf $TEMP/new-branch
   cd $TEMP
-  git init new-branch
+  git init new-branch -b master
   cd new-branch
   mkdir plugin
   echo 'let g:foo = 1' > plugin/foo.vim

test/workflow.vader

@@ -371,6 +371,9 @@ Execute (PlugDiff - 'No updates.'):
   q
 
 Execute (New commits on remote, PlugUpdate, then PlugDiff):
+  let g:plug_window = 'vertical topleft new'
+  let g:plug_pwindow = 'above 12new'
+
   for repo in ['seoul256.vim', 'vim-emoji']
     for _ in range(2)
       call system(printf('cd /tmp/vim-plug-test/junegunn/%s && git commit --allow-empty -m "update"', repo))
@@ -393,6 +396,14 @@ Execute (New commits on remote, PlugUpdate, then PlugDiff):
   let lnum = line('.')
   AssertEqual 3, col('.')
 
+  " Open full diff (empty)
+  execute "normal \<cr>"
+  wincmd P
+  AssertEqual 1, &previewwindow
+  AssertEqual 'git', &filetype
+  AssertEqual [''], getline(1, '$')
+  pclose
+
   " Open commit preview
   execute "normal j\<cr>"
   wincmd P
@@ -450,6 +461,8 @@ Execute (New commits on remote, PlugUpdate, then PlugDiff):
   AssertEqual 1, &previewwindow
   pclose
 
+  unlet g:plug_window g:plug_pwindow
+
 Execute (Test g:plug_pwindow):
   let g:plug_pwindow = 'below 5new'
   PlugDiff
@@ -791,6 +804,14 @@ Execute (Check &rtp after SomeCommand):
   AssertEqual g:first_rtp, split(&rtp, ',')[0]
   AssertEqual g:last_rtp, split(&rtp, ',')[-1]
 
+Execute (PlugClean should not care about frozen plugins):
+  call plug#begin()
+  Plug 'xxx/vim-easy-align', { 'frozen': 1 }
+  call plug#end()
+  PlugClean
+  AssertExpect 'Already clean', 1
+  q
+
 Execute (Common parent):
   call plug#begin()
   Plug 'junegunn/vim-pseudocl'
@@ -975,7 +996,8 @@ Execute (PlugInstall!):
   Assert filereadable(g:plugs['vim-easy-align'].dir.'/installed2'),
     \ 'vim-easy-align/installed2 should exist'
   AssertEqual '7f8cd78cb1fe52185b98b16a3749811f0cc508af', GitCommit('vim-pseudocl')
-  AssertEqual 'no-t_co', GitBranch('seoul256.vim')
+  " Was updated to the default branch of origin by previous PlugUpdate
+  AssertEqual 'master', GitBranch('seoul256.vim')
   AssertEqual '1.5.3', GitTag('goyo.vim')
 
 Execute (When submodules are not initialized):
@@ -1208,7 +1230,7 @@ Execute (Filetype-based on-demand loading):
   AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
 
   setf xxx
-  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/syntax', 'xxx/after/syntax', 'xxx/ftplugin', 'xxx/after/ftplugin', 'xxx/indent', 'xxx/after/indent'], g:xxx
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/syntax', 'xxx/after/syntax'], g:xxx
 
   " syntax/xxx.vim and after/syntax/xxx.vim should not be loaded (#410)
   setf yyy
@@ -1620,10 +1642,12 @@ Execute (Commit hash support):
   Assert empty(mapcheck('X'))
   Assert !empty(mapcheck("\<cr>"))
 
-  " Nor in PlugSnapshot output
+  " The exact hash values in PlugSnapshot output
   PlugSnapshot
   Log getline(1, '$')
-  AssertEqual 8, line('$')
+  AssertEqual "silent! let g:plugs['goyo.vim'].commit = 'ffffffff'", getline(6)
+  AssertEqual "silent! let g:plugs['vim-emoji'].commit = '9db7fcfee0d90dafdbcb7a32090c0a9085eb054a'", getline(7)
+  AssertEqual 10, line('$')
   q
 
 Execute (Commit hash support - cleared):
@@ -1698,6 +1722,8 @@ Execute (#530 - Comparison of incompatible git URIs):
   Assert !CompareURI('https://github.com/junegunn/vim-plug.git', 'https://github.com:12345/junegunn/vim-plug.git')
 
 Execute (#532 - Reuse plug window):
+  let g:plug_window = 'vertical topleft new'
+  let g:plug_pwindow = 'above 12new'
   call plug#begin()
   Plug 'junegunn/goyo.vim'
   call plug#end()
@@ -1724,6 +1750,8 @@ Execute (#532 - Reuse plug window):
   AssertEqual 2, winnr('$'), 'Three windows after PlugStatus (but got '.winnr('$').')'
   q
 
+  unlet g:plug_window g:plug_pwindow
+
 Execute (#766 - Allow cloning into an empty directory):
   let d = '/tmp/vim-plug-test/goyo-already'
   call system('rm -rf ' . d)