Enable syntax only during startup

Related discussion can be found in #83. If the user choose not to use
syntax highlighting, he can disable it by putting `syntax off` after
`plug#end()`. But since `plug#end()` is called by `PlugInstall` or
`PlugUpdate`, it is reenabled on those commands which is not desirable.
This commit fixes the issue by changing `plug#end` to do `syntax enable`
only during Vim startup.

README.md

@@ -1,5 +1,5 @@
 ![vim-plug](https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.png)
-![travis-ci](https://travis-ci.org/junegunn/vim-plug.svg?branch=master)
+[![travis-ci](https://travis-ci.org/junegunn/vim-plug.svg?branch=master)](https://travis-ci.org/junegunn/vim-plug)
 
 A minimalist Vim plugin manager.
 
@@ -97,6 +97,7 @@ Reload .vimrc and `:PlugInstall` to install plugins.
 - `D` - `PlugDiff`
 - `S` - `PlugStatus`
 - `R` - Retry failed update or installation tasks
+- `U` - Update plugins in the selected range
 - `q` - Close the window
 - `:PlugStatus`
     - `L` - Load plugin
@@ -130,6 +131,10 @@ Plug 'kovisoft/paredit', { 'for': ['clojure', 'scheme'] }
 Plug 'junegunn/vader.vim',  { 'on': 'Vader', 'for': 'vader' }
 ```
 
+`for` option is generally not needed as most plugins for specific file types
+usually don't have too much code in `plugin` directory. You might want to
+examine the output of `vim --startuptime` before applying the option.
+
 ### Post-update hooks
 
 There are some plugins that require extra steps after installation or update.

plug.vim

@@ -72,7 +72,7 @@ let s:plug_source = 'https://raw.githubusercontent.com/junegunn/vim-plug/master/
 let s:plug_buf = get(s:, 'plug_buf', -1)
 let s:mac_gui = has('gui_macvim') && has('gui_running')
 let s:is_win = has('win32') || has('win64')
-let s:me = expand('<sfile>:p')
+let s:me = resolve(expand('<sfile>:p'))
 let s:base_spec = { 'branch': 'master', 'frozen': 0 }
 let s:TYPE = {
 \   'string':  type(''),
@@ -84,7 +84,7 @@ let s:loaded = get(s:, 'loaded', {})
 
 function! plug#begin(...)
   if a:0 > 0
-    let home = s:path(fnamemodify(a:1, ':p'))
+    let home = s:path(fnamemodify(expand(a:1), ':p'))
   elseif exists('g:plug_home')
     let home = s:path(g:plug_home)
   elseif !empty(&rtp)
@@ -107,8 +107,8 @@ function! s:define_commands()
   if !executable('git')
     return s:err('`git` executable not found. vim-plug requires git.')
   endif
-  command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install('<bang>' == '!', <f-args>)
+  command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install('<bang>' == '!', [<f-args>])
-  command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate  call s:update('<bang>' == '!', <f-args>)
+  command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate  call s:update('<bang>' == '!', [<f-args>])
   command! -nargs=0 -bar -bang PlugClean call s:clean('<bang>' == '!')
   command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:me | endif
   command! -nargs=0 -bar PlugStatus  call s:status()
@@ -128,7 +128,6 @@ function! s:source(from, ...)
 endfunction
 
 function! plug#end()
-  let reload = !has('vim_starting')
   if !exists('g:plugs')
     return s:err('Call plug#begin() first')
   endif
@@ -142,17 +141,10 @@ function! plug#end()
   let lod = {}
 
   filetype off
-  " we want to make sure the plugin directories are added to rtp in the same
+  for name in g:plugs_order
-  " order that they are registered with the Plug command. since the s:add_rtp
-  " function uses ^= to add plugin directories to the front of the rtp, we
-  " need to loop through the plugins in reverse
-  for name in reverse(copy(g:plugs_order))
     let plug = g:plugs[name]
-    if get(s:loaded, plug.dir, 0) || !has_key(plug, 'on') && !has_key(plug, 'for')
+    if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for')
-      let rtp = s:add_rtp(plug)
+      let s:loaded[name] = 1
-      if reload
-        call s:source(rtp, 'plugin/**/*.vim', 'after/plugin/**/*.vim')
-      endif
       continue
     endif
 
@@ -192,12 +184,27 @@ function! plug#end()
   for [key, names] in items(lod)
     augroup PlugLOD
       execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)',
-            \ key, string(key), string(reverse(names)))
+            \ key, string(key), string(names))
     augroup END
   endfor
+
   call s:reorg_rtp()
   filetype plugin indent on
-  syntax on
+  if has('vim_starting')
+    syntax enable
+  else
+    call s:reload()
+  endif
+endfunction
+
+function! s:loaded_names()
+  return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)')
+endfunction
+
+function! s:reload()
+  for name in s:loaded_names()
+    call s:source(s:rtp(g:plugs[name]), 'plugin/**/*.vim', 'after/plugin/**/*.vim')
+  endfor
 endfunction
 
 function! s:trim(str)
@@ -246,27 +253,46 @@ function! s:err(msg)
 endfunction
 
 function! s:esc(path)
-  return substitute(a:path, ' ', '\\ ', 'g')
+  return escape(a:path, ' ')
 endfunction
 
-function! s:add_rtp(plug)
+function! s:escrtp(path)
-  let rtp = s:rtp(a:plug)
+  return escape(a:path, ' ,')
-  execute 'set rtp^='.s:esc(rtp)
+endfunction
+
+function! s:remove_rtp()
+  for name in s:loaded_names()
+    let rtp = s:rtp(g:plugs[name])
+    execute 'set rtp-='.s:escrtp(rtp)
     let after = globpath(rtp, 'after')
     if isdirectory(after)
-    execute 'set rtp+='.s:esc(after)
+      execute 'set rtp-='.s:escrtp(after)
     endif
-  let s:loaded[a:plug.dir] = 1
+  endfor
-  return rtp
 endfunction
 
 function! s:reorg_rtp()
   if !empty(s:first_rtp)
     execute 'set rtp-='.s:first_rtp
-    execute 'set rtp^='.s:first_rtp
-  endif
-  if s:last_rtp !=# s:first_rtp
     execute 'set rtp-='.s:last_rtp
+  endif
+
+  " &rtp is modified from outside
+  if exists('s:prtp') && s:prtp !=# &rtp
+    call s:remove_rtp()
+    unlet! s:middle
+  endif
+
+  let s:middle = get(s:, 'middle', &rtp)
+  let rtps     = map(s:loaded_names(), 's:rtp(g:plugs[v:val])')
+  let afters   = filter(map(copy(rtps), 'globpath(v:val, "after")'), 'isdirectory(v:val)')
+  let &rtp     = join(map(rtps, 's:escrtp(v:val)'), ',')
+                 \ . substitute(','.s:middle.',', '^,,$', ',', '')
+                 \ . join(map(afters, 's:escrtp(v:val)'), ',')
+  let s:prtp   = &rtp
+
+  if !empty(s:first_rtp)
+    execute 'set rtp^='.s:first_rtp
     execute 'set rtp+='.s:last_rtp
   endif
 endfunction
@@ -284,25 +310,28 @@ function! plug#load(...)
     return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', ')))
   end
   for name in a:000
-    call s:lod(g:plugs[name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+    call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
   endfor
-  call s:reorg_rtp()
   silent! doautocmd BufRead
   return 1
 endfunction
 
-function! s:lod(plug, types)
+function! s:lod(names, types)
-  let rtp = s:add_rtp(a:plug)
+  for name in a:names
+    let s:loaded[name] = 1
+  endfor
+  call s:reorg_rtp()
+
+  for name in a:names
+    let rtp = s:rtp(g:plugs[name])
     for dir in a:types
       call s:source(rtp, dir.'/**/*.vim')
     endfor
+  endfor
 endfunction
 
 function! s:lod_ft(pat, names)
-  for name in a:names
+  call s:lod(a:names, ['plugin', 'after/plugin'])
-    call s:lod(g:plugs[name], ['plugin', 'after/plugin'])
-  endfor
-  call s:reorg_rtp()
   execute 'autocmd! PlugLOD FileType' a:pat
   silent! doautocmd filetypeplugin FileType
   silent! doautocmd filetypeindent FileType
@@ -310,16 +339,14 @@ endfunction
 
 function! s:lod_cmd(cmd, bang, l1, l2, args, name)
   execute 'delc' a:cmd
-  call s:lod(g:plugs[a:name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+  call s:lod([a:name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
-  call s:reorg_rtp()
   execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args)
 endfunction
 
 function! s:lod_map(map, name, prefix)
   execute 'unmap' a:map
   execute 'iunmap' a:map
-  call s:lod(g:plugs[a:name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
+  call s:lod([a:name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
-  call s:reorg_rtp()
   let extra = ''
   while 1
     let c = getchar(0)
@@ -343,7 +370,7 @@ function! s:add(repo, ...)
                     \ a:0 == 1 ? s:parse_options(a:1) : s:base_spec)
     let g:plugs[name] = spec
     let g:plugs_order += [name]
-    let s:loaded[spec.dir] = 0
+    let s:loaded[name] = 0
   catch
     return s:err(v:exception)
   endtry
@@ -387,12 +414,12 @@ function! s:infer_properties(name, repo)
   endif
 endfunction
 
-function! s:install(force, ...)
+function! s:install(force, names)
-  call s:update_impl(0, a:force, a:000)
+  call s:update_impl(0, a:force, a:names)
 endfunction
 
-function! s:update(force, ...)
+function! s:update(force, names)
-  call s:update_impl(1, a:force, a:000)
+  call s:update_impl(1, a:force, a:names)
 endfunction
 
 function! plug#helptags()
@@ -476,10 +503,12 @@ function! s:prepare()
     silent %d _
   else
     call s:new_window()
-    nnoremap <silent> <buffer> q  :if b:plug_preview==1<bar>pc<bar>endif<bar>q<cr>
+    nnoremap <silent> <buffer> q  :if b:plug_preview==1<bar>pc<bar>endif<bar>echo<bar>q<cr>
     nnoremap <silent> <buffer> R  :silent! call <SID>retry()<cr>
     nnoremap <silent> <buffer> D  :PlugDiff<cr>
     nnoremap <silent> <buffer> S  :PlugStatus<cr>
+    nnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
+    xnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
     nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr>
     nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr>
     let b:plug_preview = -1
@@ -624,9 +653,9 @@ function! s:update_impl(pull, force, args) abort
     catch
       let lines = getline(4, '$')
       let printed = {}
-      silent 4,$d
+      silent 4,$d _
       for line in lines
-        let name = get(matchlist(line, '^. \([^:]\+\):'), 1, '')
+        let name = matchstr(line, '^. \zs[^:]\+\ze:')
         if empty(name) || !has_key(printed, name)
           call append('$', line)
           if !empty(name)
@@ -723,7 +752,7 @@ function! s:update_parallel(pull, todo, threads)
 
   def killall pid
     pids = [pid]
-    unless `which pgrep`.empty?
+    unless `which pgrep 2> /dev/null`.empty?
       children = pids
       until children.empty?
         children = children.map { |pid|
@@ -789,7 +818,7 @@ function! s:update_parallel(pull, todo, threads)
       logh.call
     end
   }
-  bt = proc { |cmd, name, type|
+  bt = proc { |cmd, name, type, cleanup|
     tried = timeout = 0
     begin
       tried += 1
@@ -820,6 +849,7 @@ function! s:update_parallel(pull, todo, threads)
         killall fd.pid
         fd.close
       end
+      cleanup.call if cleanup
       if e.is_a?(Timeout::Error) && tried < tries
         3.downto(1) do |countdown|
           s = countdown > 1 ? 's' : ''
@@ -868,7 +898,7 @@ function! s:update_parallel(pull, todo, threads)
           ok, result =
             if exists
               dir = esc dir
-              ret, data = bt.call "#{cd} #{dir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config remote.origin.url", nil, nil
+              ret, data = bt.call "#{cd} #{dir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config remote.origin.url", nil, nil, nil
               current_uri = data.lines.to_a.last
               if !ret
                 if data =~ /^Interrupted|^Timeout/
@@ -883,7 +913,7 @@ function! s:update_parallel(pull, todo, threads)
               else
                 if pull
                   log.call name, 'Updating ...', :update
-                  bt.call "#{cd} #{dir} && git checkout -q #{branch} 2>&1 && (git pull --no-rebase origin #{branch} #{progress} 2>&1 && #{subm})", name, :update
+                  bt.call "#{cd} #{dir} && git checkout -q #{branch} 2>&1 && (git pull --no-rebase origin #{branch} #{progress} 2>&1 && #{subm})", name, :update, nil
                 else
                   [true, skip]
                 end
@@ -891,7 +921,9 @@ function! s:update_parallel(pull, todo, threads)
             else
               d = esc dir.sub(%r{[\\/]+$}, '')
               log.call name, 'Installing ...', :install
-              bt.call "(git clone #{progress} --recursive #{uri} -b #{branch} #{d} 2>&1 && cd #{esc dir} && #{subm})", name, :install
+              bt.call "(git clone #{progress} --recursive #{uri} -b #{branch} #{d} 2>&1 && cd #{esc dir} && #{subm})", name, :install, proc {
+                FileUtils.rm_rf dir
+              }
             end
           mtx.synchronize { VIM::command("let s:prev_update.new['#{name}'] = 1") } if !exists && ok
           log.call name, result, ok
@@ -1037,44 +1069,40 @@ function! s:clean(force)
 endfunction
 
 function! s:upgrade()
-  if executable('curl')
+  let new = s:me . '.new'
-    let mee = s:shellesc(s:me)
-    let new = s:shellesc(s:me . '.new')
   echo 'Downloading '. s:plug_source
   redraw
-    let mv = s:is_win ? 'move /Y' : 'mv -f'
+  try
-    let cp = s:is_win ? 'copy /Y' : 'cp -f'
+    if executable('curl')
-    call system(printf(
+      let output = system(printf('curl -fLo %s %s', s:shellesc(new), s:plug_source))
-      \ 'curl -fLo %s %s && '.cp.' %s %s.old && '.mv.' %s %s',
-      \ new, s:plug_source, mee, mee, new, mee))
       if v:shell_error
-      return s:err('Error upgrading vim-plug')
+        throw get(split(output, '\n'), -1, v:shell_error)
       endif
     elseif has('ruby')
-    echo 'Downloading '. s:plug_source
-    try
       ruby << EOF
       require 'open-uri'
-      require 'fileutils'
+      File.open(VIM::evaluate('new'), 'w') do |f|
-      me  = VIM::evaluate('s:me')
-      old = me + '.old'
-      new = me + '.new'
-      File.open(new, 'w') do |f|
         f << open(VIM::evaluate('s:plug_source')).read
       end
-      FileUtils.cp me, old
-      File.rename  new, me
 EOF
-    catch
-      return s:err('Error upgrading vim-plug')
-    endtry
     else
       return s:err('curl executable or ruby support not found')
     endif
+  catch
+    return s:err('Error upgrading vim-plug: '. v:exception)
+  endtry
 
+  if readfile(s:me) ==# readfile(new)
+    echo 'vim-plug is up-to-date'
+    silent! call delete(new)
+    return 0
+  else
+    call rename(s:me, s:me . '.old')
+    call rename(new, s:me)
     unlet g:loaded_plug
-  echo 'Downloaded '. s:plug_source
+    echo 'vim-plug is upgraded'
     return 1
+  endif
 endfunction
 
 function! s:upgrade_specs()
@@ -1108,7 +1136,7 @@ function! s:status()
     let cnt += 1
     let ecnt += !valid
     " `s:loaded` entry can be missing if PlugUpgraded
-    if valid && get(s:loaded, spec.dir, -1) == 0
+    if valid && get(s:loaded, name, -1) == 0
       let unloaded = 1
       let msg .= ' (not loaded)'
     endif
@@ -1121,17 +1149,20 @@ function! s:status()
   normal! gg
   setlocal nomodifiable
   if unloaded
-    echo "Press 'L' on each line to load plugin"
+    echo "Press 'L' on each line to load plugin, or 'U' to update"
     nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
     xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
   end
 endfunction
 
+function! s:extract_name(str, prefix, suffix)
+  return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$')
+endfunction
+
 function! s:status_load(lnum)
   let line = getline(a:lnum)
-  let matches = matchlist(line, '^- \([^:]*\):.*(not loaded)$')
+  let name = s:extract_name(line, '-', '(not loaded)')
-  if !empty(matches)
+  if !empty(name)
-    let name = matches[1]
     call plug#load(name)
     setlocal modifiable
     call setline(a:lnum, substitute(line, ' (not loaded)$', '', ''))
@@ -1139,6 +1170,15 @@ function! s:status_load(lnum)
   endif
 endfunction
 
+function! s:status_update() range
+  let lines = getline(a:firstline, a:lastline)
+  let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)')
+  if !empty(names)
+    echo
+    execute 'PlugUpdate' join(names)
+  endif
+endfunction
+
 function! s:is_preview_window_open()
   silent! wincmd P
   if &previewwindow
@@ -1242,8 +1282,12 @@ function! s:revert()
   echo 'Reverted.'
 endfunction
 
-let s:first_rtp = s:esc(get(split(&rtp, ','), 0, ''))
+function! s:split_rtp()
-let s:last_rtp = s:esc(get(split(&rtp, ','), -1, ''))
+  return split(&rtp, '\\\@<!,')
+endfunction
+
+let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, ''))
+let s:last_rtp  = s:escrtp(get(s:split_rtp(), -1, ''))
 
 if exists('g:plugs')
   let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs))

test/run

@@ -19,10 +19,14 @@ make_dirs() {
   cd "$1"
   mkdir -p autoload colors ftdetect ftplugin indent plugin syntax
   for d in *; do
+    [ -d $d ] || continue
     cat > $d/xxx.vim << EOF
     " echom expand('<sfile>')
+    let g:total_order = get(g:, 'total_order', [])
     let g:$2 = get(g:, '$2', [])
-    call add(g:$2, '${1:4}/$d')
+    let s:name = join(filter(['$2', '${1:4}', '$d'], '!empty(v:val)'), '/')
+    call add(g:$2, s:name)
+    call add(g:total_order, s:name)
 EOF
   done
   cd - > /dev/null
@@ -30,12 +34,14 @@ EOF
 
 make_dirs xxx/ xxx
 make_dirs xxx/after xxx
-mkdir xxx/doc
+mkdir -p xxx/doc
 cat > xxx/doc/xxx.txt << DOC
 hello *xxx*
 DOC
 
 make_dirs yyy/ yyy
+make_dirs yyy/after yyy
+
 make_dirs z1/ z1
 make_dirs z2/ z2
 

test/workflow.vader

@@ -27,11 +27,17 @@ Execute (Initialize test environment):
   endfunction
 
   function! AssertExpect(bang, pat, cnt)
-    let op = a:bang ? '==' : '=~'
+    let op = a:bang ? '==#' : '=~#'
     AssertEqual a:cnt, len(filter(getline(1, '$'), "v:val ".op." '".a:pat."'"))
   endfunction
   command! -nargs=+ -bang AssertExpect call AssertExpect('<bang>' == '!', <args>)
 
+  function! EnsureLoaded()
+    if has('vim_starting')
+      runtime! plugin/**/*.vim
+    endif
+  endfunction
+
 Execute (Print Ruby version):
   redir => out
   silent ruby puts RUBY_VERSION
@@ -388,10 +394,7 @@ Given (Unaligned code):
   aa=2
 
 Execute (Check installed plugins):
-  if has('vim_starting')
+  call EnsureLoaded()
-    Log 'Vader is run from commandline'
-    runtime! plugin/**/*.vim
-  endif
   Assert exists(':FNR'),           'FNR command should be found'
   Assert !exists(':RedisExecute'), 'RedisExecute command still should not be found'
 
@@ -740,9 +743,9 @@ Execute (Immediate loading):
   " Different result when Vader is run from commandline with `-c` option
   Log g:xxx
   if has('vim_starting')
-    AssertEqual ['/ftdetect', 'after/ftdetect'], g:xxx
+    AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
   else
-    AssertEqual ['/plugin', 'after/plugin', '/ftdetect', 'after/ftdetect'], g:xxx
+    AssertEqual ['xxx/plugin', 'xxx/after/plugin', 'xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
   endif
 
 Execute (Command-based on-demand loading):
@@ -753,20 +756,20 @@ Execute (Command-based on-demand loading):
   AssertEqual [], g:xxx
 
   silent! XXX
-  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin'], g:xxx
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin'], g:xxx
 
   setf xxx
-  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin', '/ftplugin', 'after/ftplugin', '/indent', 'after/indent', '/syntax', 'after/syntax'], g:xxx
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/ftplugin', 'xxx/after/ftplugin', 'xxx/indent', 'xxx/after/indent', 'xxx/syntax', 'xxx/after/syntax'], g:xxx
 
 Execute (Filetype-based on-demand loading):
   call plug#begin()
   Plug '$PWD/xxx', { 'for': 'xxx' }
   call plug#end()
 
-  AssertEqual ['/ftdetect', 'after/ftdetect'], g:xxx
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
 
   setf xxx
-  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin', '/ftplugin', 'after/ftplugin', '/indent', 'after/indent', '/syntax', 'after/syntax'], g:xxx
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/ftplugin', 'xxx/after/ftplugin', 'xxx/indent', 'xxx/after/indent', 'xxx/syntax', 'xxx/after/syntax'], g:xxx
 
 Before:
 
@@ -873,6 +876,7 @@ Execute (Open plug window in a new tab):
   normal S
   AssertEqual tabnr, tabpagenr()
   q
+  unlet g:plug_window
 
 **********************************************************************
 ~ g:plug_url_format
@@ -885,6 +889,120 @@ Execute (Using g:plug_url_format):
   Plug 'beauty256'
   AssertEqual 'git@bitbucket.org:junegunn/seoul256.vim.git', g:plugs['seoul256.vim'].uri
   AssertEqual 'git@bitsocket.org:vim-scripts/beauty256.git', g:plugs['beauty256'].uri
+  unlet g:plug_url_format
+
+**********************************************************************
+~ U
+**********************************************************************
+Execute (Plug block):
+  call plug#begin()
+  Plug 'junegunn/vim-easy-align'
+  Plug 'junegunn/vim-emoji'
+  call plug#end()
+
+Execute (Update plugin with U key in normal mode):
+  PlugStatus
+  /emoji
+  normal U
+  Log getline(1, '$')
+  AssertExpect 'Updated', 1
+  AssertExpect 'vim-emoji', 1
+  AssertExpect 'vim-easy-align', 0
+  AssertExpect! '[=]', 1
+
+  " From PlugInstall screen
+  PlugInstall
+  /easy-align
+  normal U
+  AssertExpect 'Updated', 1
+  AssertExpect 'vim-emoji', 0
+  AssertExpect 'vim-easy-align', 1
+  AssertExpect! '[=]', 1
+  q
+
+Execute (Update plugins with U key in visual mode):
+  silent! call system('rm -rf '.g:plugs['vim-easy-align'].dir)
+
+  PlugStatus
+  normal VGU
+  Log getline(1, '$')
+  AssertExpect 'Updated', 1
+  AssertExpect 'vim-emoji', 1
+  AssertExpect 'vim-easy-align', 1
+  AssertExpect! '[==]', 1
+
+  " From PlugUpdate screen
+  normal VGU
+  Log getline(1, '$')
+  AssertExpect 'Updated', 1
+  AssertExpect 'vim-emoji', 1
+  AssertExpect 'vim-easy-align', 1
+  AssertExpect! '[==]', 1
+  q
+
+**********************************************************************
+Execute (plug#begin should expand env vars):
+  AssertNotEqual '$HOME/.emacs/plugged', expand('$HOME/.emacs/plugged')
+  call plug#begin('$HOME/.emacs/plugged')
+  AssertEqual expand('$HOME/.emacs/plugged'), g:plug_home
+
+**********************************************************************
+Execute (Plug directory with comma):
+  call plug#begin(temp_plugged . '/p,l,u,g,g,e,d')
+  Plug 'junegunn/vim-emoji'
+  call plug#end()
+  Log &rtp
+
+  PlugInstall
+  q
+  let found = filter(split(globpath(&rtp, 'README.md'), '\n'), 'v:val =~ ","')
+  Log found
+  AssertEqual 1, len(found)
+
+**********************************************************************
+Execute (Strict load order):
+  let g:total_order = []
+  call plug#begin()
+  Plug '$PWD/xxx'
+  Plug '$PWD/yyy', { 'for': ['xxx'] }
+  call plug#end()
+  call EnsureLoaded()
+  setf xxx
+  Log 'Case 1: ' . &rtp
+  AssertEqual ['yyy/ftdetect', 'yyy/after/ftdetect', 'xxx/ftdetect', 'xxx/after/ftdetect'], g:total_order[0:3]
+  Assert index(g:total_order, 'xxx/plugin') < index(g:total_order, 'yyy/plugin')
+  Assert index(g:total_order, 'xxx/after/plugin') < index(g:total_order, 'yyy/after/plugin')
+  let len = len(split(&rtp, ','))
+
+  let g:total_order = []
+  call plug#begin()
+  Plug '$PWD/xxx', { 'for': ['xxx'] }
+  Plug '$PWD/yyy'
+  call plug#end()
+  call EnsureLoaded()
+  set rtp^=manually-prepended
+  set rtp+=manually-appended
+  setf xxx
+  Log 'Case 2: ' . &rtp
+  AssertEqual 'manually-prepended', split(&rtp, ',')[3]
+  AssertEqual 'manually-appended',  split(&rtp, ',')[-4]
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'yyy/ftdetect', 'yyy/after/ftdetect'], g:total_order[0:3]
+  Assert index(g:total_order, 'yyy/plugin') < index(g:total_order, 'xxx/plugin')
+  Assert index(g:total_order, 'yyy/after/plugin') < index(g:total_order, 'xxx/after/plugin')
+  AssertEqual len + 2, len(split(&rtp, ','))
+
+  let g:total_order = []
+  call plug#begin()
+  Plug '$PWD/xxx', { 'for': ['xxx'] }
+  Plug '$PWD/yyy', { 'for': ['xxx'] }
+  call plug#end()
+  call EnsureLoaded()
+  setf xxx
+  Log 'Case 3: ' . &rtp
+  AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'yyy/ftdetect', 'yyy/after/ftdetect'], g:total_order[0:3]
+  Assert index(g:total_order, 'xxx/plugin') < index(g:total_order, 'yyy/plugin')
+  Assert index(g:total_order, 'xxx/after/plugin') < index(g:total_order, 'yyy/after/plugin')
+  AssertEqual len + 2, len(split(&rtp, ','))
 
 Execute (Cleanup):
   silent! call system('rm -rf '.temp_plugged)
@@ -892,10 +1010,11 @@ Execute (Cleanup):
   silent! unlet g:plugs
   silent! unlet g:plug_home
   silent! unlet g:plug_url_format
-  silent! unlet temp_plugged vader plug basertp save_rtp repo lnum fzf out tabnr
+  silent! unlet temp_plugged vader plug basertp save_rtp repo lnum fzf out tabnr found len
   silent! delf PlugStatusSorted
   silent! delf AssertExpect
   silent! delf PlugUpdated
+  silent! delf EnsureLoaded
   silent! delc AssertExpect
   silent! unmap /
   silent! unmap ?