git.r.bdr.sh - rbdr/dotfiles/blob - vim/autoload/plug.vim

   1 " vim-plug: Vim plugin manager
   2 " ============================
   3 "
   4 " Download plug.vim and put it in ~/.vim/autoload
   5 "
   6 "   curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
   7 "     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
   8 "
   9 " Edit your .vimrc
  10 "
  11 "   call plug#begin('~/.vim/plugged')
  12 "
  13 "   " Make sure you use single quotes
  14 "
  15 "   " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
  16 "   Plug 'junegunn/vim-easy-align'
  17 "
  18 "   " Any valid git URL is allowed
  19 "   Plug 'https://github.com/junegunn/vim-github-dashboard.git'
  20 "
  21 "   " Multiple Plug commands can be written in a single line using | separators
  22 "   Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
  23 "
  24 "   " On-demand loading
  25 "   Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
  26 "   Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
  27 "
  28 "   " Using a non-default branch
  29 "   Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
  30 "
  31 "   " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
  32 "   Plug 'fatih/vim-go', { 'tag': '*' }
  33 "
  34 "   " Plugin options
  35 "   Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
  36 "
  37 "   " Plugin outside ~/.vim/plugged with post-update hook
  38 "   Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
  39 "
  40 "   " Unmanaged plugin (manually installed and updated)
  41 "   Plug '~/my-prototype-plugin'
  42 "
  43 "   " Initialize plugin system
  44 "   call plug#end()
  45 "
  46 " Then reload .vimrc and :PlugInstall to install plugins.
  47 "
  48 " Plug options:
  49 "
  50 "| Option                  | Description                                      |
  51 "| ----------------------- | ------------------------------------------------ |
  52 "| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use       |
  53 "| `rtp`                   | Subdirectory that contains Vim plugin            |
  54 "| `dir`                   | Custom directory for the plugin                  |
  55 "| `as`                    | Use different name for the plugin                |
  56 "| `do`                    | Post-update hook (string or funcref)             |
  57 "| `on`                    | On-demand loading: Commands or `<Plug>`-mappings |
  58 "| `for`                   | On-demand loading: File types                    |
  59 "| `frozen`                | Do not update unless explicitly specified        |
  60 "
  61 " More information: https://github.com/junegunn/vim-plug
  62 "
  63 "
  64 " Copyright (c) 2017 Junegunn Choi
  65 "
  66 " MIT License
  67 "
  68 " Permission is hereby granted, free of charge, to any person obtaining
  69 " a copy of this software and associated documentation files (the
  70 " "Software"), to deal in the Software without restriction, including
  71 " without limitation the rights to use, copy, modify, merge, publish,
  72 " distribute, sublicense, and/or sell copies of the Software, and to
  73 " permit persons to whom the Software is furnished to do so, subject to
  74 " the following conditions:
  75 "
  76 " The above copyright notice and this permission notice shall be
  77 " included in all copies or substantial portions of the Software.
  78 "
  79 " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  80 " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  81 " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  82 " NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  83 " LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  84 " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  85 " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  86
  87 if exists('g:loaded_plug')
  88   finish
  89 endif
  90 let g:loaded_plug = 1
  91
  92 let s:cpo_save = &cpo
  93 set cpo&vim
  94
  95 let s:plug_src = 'https://github.com/junegunn/vim-plug.git'
  96 let s:plug_tab = get(s:, 'plug_tab', -1)
  97 let s:plug_buf = get(s:, 'plug_buf', -1)
  98 let s:mac_gui = has('gui_macvim') && has('gui_running')
  99 let s:is_win = has('win32')
 100 let s:nvim = has('nvim-0.2') || (has('nvim') && exists('*jobwait') && !s:is_win)
 101 let s:vim8 = has('patch-8.0.0039') && exists('*job_start')
 102 if s:is_win && &shellslash
 103   set noshellslash
 104   let s:me = resolve(expand('<sfile>:p'))
 105   set shellslash
 106 else
 107   let s:me = resolve(expand('<sfile>:p'))
 108 endif
 109 let s:base_spec = { 'branch': '', 'frozen': 0 }
 110 let s:TYPE = {
 111 \   'string':  type(''),
 112 \   'list':    type([]),
 113 \   'dict':    type({}),
 114 \   'funcref': type(function('call'))
 115 \ }
 116 let s:loaded = get(s:, 'loaded', {})
 117 let s:triggers = get(s:, 'triggers', {})
 118
 119 function! s:is_powershell(shell)
 120   return a:shell =~# 'powershell\(\.exe\)\?$' || a:shell =~# 'pwsh\(\.exe\)\?$'
 121 endfunction
 122
 123 function! s:isabsolute(dir) abort
 124   return a:dir =~# '^/' || (has('win32') && a:dir =~? '^\%(\\\|[A-Z]:\)')
 125 endfunction
 126
 127 function! s:git_dir(dir) abort
 128   let gitdir = s:trim(a:dir) . '/.git'
 129   if isdirectory(gitdir)
 130     return gitdir
 131   endif
 132   if !filereadable(gitdir)
 133     return ''
 134   endif
 135   let gitdir = matchstr(get(readfile(gitdir), 0, ''), '^gitdir: \zs.*')
 136   if len(gitdir) && !s:isabsolute(gitdir)
 137     let gitdir = a:dir . '/' . gitdir
 138   endif
 139   return isdirectory(gitdir) ? gitdir : ''
 140 endfunction
 141
 142 function! s:git_origin_url(dir) abort
 143   let gitdir = s:git_dir(a:dir)
 144   let config = gitdir . '/config'
 145   if empty(gitdir) || !filereadable(config)
 146     return ''
 147   endif
 148   return matchstr(join(readfile(config)), '\[remote "origin"\].\{-}url\s*=\s*\zs\S*\ze')
 149 endfunction
 150
 151 function! s:git_revision(dir) abort
 152   let gitdir = s:git_dir(a:dir)
 153   let head = gitdir . '/HEAD'
 154   if empty(gitdir) || !filereadable(head)
 155     return ''
 156   endif
 157
 158   let line = get(readfile(head), 0, '')
 159   let ref = matchstr(line, '^ref: \zs.*')
 160   if empty(ref)
 161     return line
 162   endif
 163
 164   if filereadable(gitdir . '/' . ref)
 165     return get(readfile(gitdir . '/' . ref), 0, '')
 166   endif
 167
 168   if filereadable(gitdir . '/packed-refs')
 169     for line in readfile(gitdir . '/packed-refs')
 170       if line =~# ' ' . ref
 171         return matchstr(line, '^[0-9a-f]*')
 172       endif
 173     endfor
 174   endif
 175
 176   return ''
 177 endfunction
 178
 179 function! s:git_local_branch(dir) abort
 180   let gitdir = s:git_dir(a:dir)
 181   let head = gitdir . '/HEAD'
 182   if empty(gitdir) || !filereadable(head)
 183     return ''
 184   endif
 185   let branch = matchstr(get(readfile(head), 0, ''), '^ref: refs/heads/\zs.*')
 186   return len(branch) ? branch : 'HEAD'
 187 endfunction
 188
 189 function! s:git_origin_branch(spec)
 190   if len(a:spec.branch)
 191     return a:spec.branch
 192   endif
 193
 194   " The file may not be present if this is a local repository
 195   let gitdir = s:git_dir(a:spec.dir)
 196   let origin_head = gitdir.'/refs/remotes/origin/HEAD'
 197   if len(gitdir) && filereadable(origin_head)
 198     return matchstr(get(readfile(origin_head), 0, ''),
 199                   \ '^ref: refs/remotes/origin/\zs.*')
 200   endif
 201
 202   " The command may not return the name of a branch in detached HEAD state
 203   let result = s:lines(s:system('git symbolic-ref --short HEAD', a:spec.dir))
 204   return v:shell_error ? '' : result[-1]
 205 endfunction
 206
 207 if s:is_win
 208   function! s:plug_call(fn, ...)
 209     let shellslash = &shellslash
 210     try
 211       set noshellslash
 212       return call(a:fn, a:000)
 213     finally
 214       let &shellslash = shellslash
 215     endtry
 216   endfunction
 217 else
 218   function! s:plug_call(fn, ...)
 219     return call(a:fn, a:000)
 220   endfunction
 221 endif
 222
 223 function! s:plug_getcwd()
 224   return s:plug_call('getcwd')
 225 endfunction
 226
 227 function! s:plug_fnamemodify(fname, mods)
 228   return s:plug_call('fnamemodify', a:fname, a:mods)
 229 endfunction
 230
 231 function! s:plug_expand(fmt)
 232   return s:plug_call('expand', a:fmt, 1)
 233 endfunction
 234
 235 function! s:plug_tempname()
 236   return s:plug_call('tempname')
 237 endfunction
 238
 239 function! plug#begin(...)
 240   if a:0 > 0
 241     let s:plug_home_org = a:1
 242     let home = s:path(s:plug_fnamemodify(s:plug_expand(a:1), ':p'))
 243   elseif exists('g:plug_home')
 244     let home = s:path(g:plug_home)
 245   elseif has('nvim')
 246     let home = stdpath('data') . '/plugged'
 247   elseif !empty(&rtp)
 248     let home = s:path(split(&rtp, ',')[0]) . '/plugged'
 249   else
 250     return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.')
 251   endif
 252   if s:plug_fnamemodify(home, ':t') ==# 'plugin' && s:plug_fnamemodify(home, ':h') ==# s:first_rtp
 253     return s:err('Invalid plug home. '.home.' is a standard Vim runtime path and is not allowed.')
 254   endif
 255
 256   let g:plug_home = home
 257   let g:plugs = {}
 258   let g:plugs_order = []
 259   let s:triggers = {}
 260
 261   call s:define_commands()
 262   return 1
 263 endfunction
 264
 265 function! s:define_commands()
 266   command! -nargs=+ -bar Plug call plug#(<args>)
 267   if !executable('git')
 268     return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.')
 269   endif
 270   if has('win32')
 271   \ && &shellslash
 272   \ && (&shell =~# 'cmd\(\.exe\)\?$' || s:is_powershell(&shell))
 273     return s:err('vim-plug does not support shell, ' . &shell . ', when shellslash is set.')
 274   endif
 275   if !has('nvim')
 276     \ && (has('win32') || has('win32unix'))
 277     \ && !has('multi_byte')
 278     return s:err('Vim needs +multi_byte feature on Windows to run shell commands. Enable +iconv for best results.')
 279   endif
 280   command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(<bang>0, [<f-args>])
 281   command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate  call s:update(<bang>0, [<f-args>])
 282   command! -nargs=0 -bar -bang PlugClean call s:clean(<bang>0)
 283   command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif
 284   command! -nargs=0 -bar PlugStatus  call s:status()
 285   command! -nargs=0 -bar PlugDiff    call s:diff()
 286   command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(<bang>0, <f-args>)
 287 endfunction
 288
 289 function! s:to_a(v)
 290   return type(a:v) == s:TYPE.list ? a:v : [a:v]
 291 endfunction
 292
 293 function! s:to_s(v)
 294   return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n"
 295 endfunction
 296
 297 function! s:glob(from, pattern)
 298   return s:lines(globpath(a:from, a:pattern))
 299 endfunction
 300
 301 function! s:source(from, ...)
 302   let found = 0
 303   for pattern in a:000
 304     for vim in s:glob(a:from, pattern)
 305       execute 'source' s:esc(vim)
 306       let found = 1
 307     endfor
 308   endfor
 309   return found
 310 endfunction
 311
 312 function! s:assoc(dict, key, val)
 313   let a:dict[a:key] = add(get(a:dict, a:key, []), a:val)
 314 endfunction
 315
 316 function! s:ask(message, ...)
 317   call inputsave()
 318   echohl WarningMsg
 319   let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) '))
 320   echohl None
 321   call inputrestore()
 322   echo "\r"
 323   return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0
 324 endfunction
 325
 326 function! s:ask_no_interrupt(...)
 327   try
 328     return call('s:ask', a:000)
 329   catch
 330     return 0
 331   endtry
 332 endfunction
 333
 334 function! s:lazy(plug, opt)
 335   return has_key(a:plug, a:opt) &&
 336         \ (empty(s:to_a(a:plug[a:opt]))         ||
 337         \  !isdirectory(a:plug.dir)             ||
 338         \  len(s:glob(s:rtp(a:plug), 'plugin')) ||
 339         \  len(s:glob(s:rtp(a:plug), 'after/plugin')))
 340 endfunction
 341
 342 function! plug#end()
 343   if !exists('g:plugs')
 344     return s:err('plug#end() called without calling plug#begin() first')
 345   endif
 346
 347   if exists('#PlugLOD')
 348     augroup PlugLOD
 349       autocmd!
 350     augroup END
 351     augroup! PlugLOD
 352   endif
 353   let lod = { 'ft': {}, 'map': {}, 'cmd': {} }
 354
 355   if get(g:, 'did_load_filetypes', 0)
 356     filetype off
 357   endif
 358   for name in g:plugs_order
 359     if !has_key(g:plugs, name)
 360       continue
 361     endif
 362     let plug = g:plugs[name]
 363     if get(s:loaded, name, 0) || !s:lazy(plug, 'on') && !s:lazy(plug, 'for')
 364       let s:loaded[name] = 1
 365       continue
 366     endif
 367
 368     if has_key(plug, 'on')
 369       let s:triggers[name] = { 'map': [], 'cmd': [] }
 370       for cmd in s:to_a(plug.on)
 371         if cmd =~? '^<Plug>.\+'
 372           if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i'))
 373             call s:assoc(lod.map, cmd, name)
 374           endif
 375           call add(s:triggers[name].map, cmd)
 376         elseif cmd =~# '^[A-Z]'
 377           let cmd = substitute(cmd, '!*$', '', '')
 378           if exists(':'.cmd) != 2
 379             call s:assoc(lod.cmd, cmd, name)
 380           endif
 381           call add(s:triggers[name].cmd, cmd)
 382         else
 383           call s:err('Invalid `on` option: '.cmd.
 384           \ '. Should start with an uppercase letter or `<Plug>`.')
 385         endif
 386       endfor
 387     endif
 388
 389     if has_key(plug, 'for')
 390       let types = s:to_a(plug.for)
 391       if !empty(types)
 392         augroup filetypedetect
 393         call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim')
 394         augroup END
 395       endif
 396       for type in types
 397         call s:assoc(lod.ft, type, name)
 398       endfor
 399     endif
 400   endfor
 401
 402   for [cmd, names] in items(lod.cmd)
 403     execute printf(
 404     \ 'command! -nargs=* -range -bang -complete=file %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)',
 405     \ cmd, string(cmd), string(names))
 406   endfor
 407
 408   for [map, names] in items(lod.map)
 409     for [mode, map_prefix, key_prefix] in
 410           \ [['i', '<C-\><C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']]
 411       execute printf(
 412       \ '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, %s, "%s")<CR>',
 413       \ mode, map, map_prefix, string(map), string(names), mode != 'i', key_prefix)
 414     endfor
 415   endfor
 416
 417   for [ft, names] in items(lod.ft)
 418     augroup PlugLOD
 419       execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)',
 420             \ ft, string(ft), string(names))
 421     augroup END
 422   endfor
 423
 424   call s:reorg_rtp()
 425   filetype plugin indent on
 426   if has('vim_starting')
 427     if has('syntax') && !exists('g:syntax_on')
 428       syntax enable
 429     end
 430   else
 431     call s:reload_plugins()
 432   endif
 433 endfunction
 434
 435 function! s:loaded_names()
 436   return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)')
 437 endfunction
 438
 439 function! s:load_plugin(spec)
 440   call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim')
 441 endfunction
 442
 443 function! s:reload_plugins()
 444   for name in s:loaded_names()
 445     call s:load_plugin(g:plugs[name])
 446   endfor
 447 endfunction
 448
 449 function! s:trim(str)
 450   return substitute(a:str, '[\/]\+$', '', '')
 451 endfunction
 452
 453 function! s:version_requirement(val, min)
 454   for idx in range(0, len(a:min) - 1)
 455     let v = get(a:val, idx, 0)
 456     if     v < a:min[idx] | return 0
 457     elseif v > a:min[idx] | return 1
 458     endif
 459   endfor
 460   return 1
 461 endfunction
 462
 463 function! s:git_version_requirement(...)
 464   if !exists('s:git_version')
 465     let s:git_version = map(split(split(s:system(['git', '--version']))[2], '\.'), 'str2nr(v:val)')
 466   endif
 467   return s:version_requirement(s:git_version, a:000)
 468 endfunction
 469
 470 function! s:progress_opt(base)
 471   return a:base && !s:is_win &&
 472         \ s:git_version_requirement(1, 7, 1) ? '--progress' : ''
 473 endfunction
 474
 475 function! s:rtp(spec)
 476   return s:path(a:spec.dir . get(a:spec, 'rtp', ''))
 477 endfunction
 478
 479 if s:is_win
 480   function! s:path(path)
 481     return s:trim(substitute(a:path, '/', '\', 'g'))
 482   endfunction
 483
 484   function! s:dirpath(path)
 485     return s:path(a:path) . '\'
 486   endfunction
 487
 488   function! s:is_local_plug(repo)
 489     return a:repo =~? '^[a-z]:\|^[%~]'
 490   endfunction
 491
 492   " Copied from fzf
 493   function! s:wrap_cmds(cmds)
 494     let cmds = [
 495       \ '@echo off',
 496       \ 'setlocal enabledelayedexpansion']
 497     \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds])
 498     \ + ['endlocal']
 499     if has('iconv')
 500       if !exists('s:codepage')
 501         let s:codepage = libcallnr('kernel32.dll', 'GetACP', 0)
 502       endif
 503       return map(cmds, printf('iconv(v:val."\r", "%s", "cp%d")', &encoding, s:codepage))
 504     endif
 505     return map(cmds, 'v:val."\r"')
 506   endfunction
 507
 508   function! s:batchfile(cmd)
 509     let batchfile = s:plug_tempname().'.bat'
 510     call writefile(s:wrap_cmds(a:cmd), batchfile)
 511     let cmd = plug#shellescape(batchfile, {'shell': &shell, 'script': 0})
 512     if s:is_powershell(&shell)
 513       let cmd = '& ' . cmd
 514     endif
 515     return [batchfile, cmd]
 516   endfunction
 517 else
 518   function! s:path(path)
 519     return s:trim(a:path)
 520   endfunction
 521
 522   function! s:dirpath(path)
 523     return substitute(a:path, '[/\\]*$', '/', '')
 524   endfunction
 525
 526   function! s:is_local_plug(repo)
 527     return a:repo[0] =~ '[/$~]'
 528   endfunction
 529 endif
 530
 531 function! s:err(msg)
 532   echohl ErrorMsg
 533   echom '[vim-plug] '.a:msg
 534   echohl None
 535 endfunction
 536
 537 function! s:warn(cmd, msg)
 538   echohl WarningMsg
 539   execute a:cmd 'a:msg'
 540   echohl None
 541 endfunction
 542
 543 function! s:esc(path)
 544   return escape(a:path, ' ')
 545 endfunction
 546
 547 function! s:escrtp(path)
 548   return escape(a:path, ' ,')
 549 endfunction
 550
 551 function! s:remove_rtp()
 552   for name in s:loaded_names()
 553     let rtp = s:rtp(g:plugs[name])
 554     execute 'set rtp-='.s:escrtp(rtp)
 555     let after = globpath(rtp, 'after')
 556     if isdirectory(after)
 557       execute 'set rtp-='.s:escrtp(after)
 558     endif
 559   endfor
 560 endfunction
 561
 562 function! s:reorg_rtp()
 563   if !empty(s:first_rtp)
 564     execute 'set rtp-='.s:first_rtp
 565     execute 'set rtp-='.s:last_rtp
 566   endif
 567
 568   " &rtp is modified from outside
 569   if exists('s:prtp') && s:prtp !=# &rtp
 570     call s:remove_rtp()
 571     unlet! s:middle
 572   endif
 573
 574   let s:middle = get(s:, 'middle', &rtp)
 575   let rtps     = map(s:loaded_names(), 's:rtp(g:plugs[v:val])')
 576   let afters   = filter(map(copy(rtps), 'globpath(v:val, "after")'), '!empty(v:val)')
 577   let rtp      = join(map(rtps, 'escape(v:val, ",")'), ',')
 578                  \ . ','.s:middle.','
 579                  \ . join(map(afters, 'escape(v:val, ",")'), ',')
 580   let &rtp     = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g')
 581   let s:prtp   = &rtp
 582
 583   if !empty(s:first_rtp)
 584     execute 'set rtp^='.s:first_rtp
 585     execute 'set rtp+='.s:last_rtp
 586   endif
 587 endfunction
 588
 589 function! s:doautocmd(...)
 590   if exists('#'.join(a:000, '#'))
 591     execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000)
 592   endif
 593 endfunction
 594
 595 function! s:dobufread(names)
 596   for name in a:names
 597     let path = s:rtp(g:plugs[name])
 598     for dir in ['ftdetect', 'ftplugin', 'after/ftdetect', 'after/ftplugin']
 599       if len(finddir(dir, path))
 600         if exists('#BufRead')
 601           doautocmd BufRead
 602         endif
 603         return
 604       endif
 605     endfor
 606   endfor
 607 endfunction
 608
 609 function! plug#load(...)
 610   if a:0 == 0
 611     return s:err('Argument missing: plugin name(s) required')
 612   endif
 613   if !exists('g:plugs')
 614     return s:err('plug#begin was not called')
 615   endif
 616   let names = a:0 == 1 && type(a:1) == s:TYPE.list ? a:1 : a:000
 617   let unknowns = filter(copy(names), '!has_key(g:plugs, v:val)')
 618   if !empty(unknowns)
 619     let s = len(unknowns) > 1 ? 's' : ''
 620     return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', ')))
 621   end
 622   let unloaded = filter(copy(names), '!get(s:loaded, v:val, 0)')
 623   if !empty(unloaded)
 624     for name in unloaded
 625       call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 626     endfor
 627     call s:dobufread(unloaded)
 628     return 1
 629   end
 630   return 0
 631 endfunction
 632
 633 function! s:remove_triggers(name)
 634   if !has_key(s:triggers, a:name)
 635     return
 636   endif
 637   for cmd in s:triggers[a:name].cmd
 638     execute 'silent! delc' cmd
 639   endfor
 640   for map in s:triggers[a:name].map
 641     execute 'silent! unmap' map
 642     execute 'silent! iunmap' map
 643   endfor
 644   call remove(s:triggers, a:name)
 645 endfunction
 646
 647 function! s:lod(names, types, ...)
 648   for name in a:names
 649     call s:remove_triggers(name)
 650     let s:loaded[name] = 1
 651   endfor
 652   call s:reorg_rtp()
 653
 654   for name in a:names
 655     let rtp = s:rtp(g:plugs[name])
 656     for dir in a:types
 657       call s:source(rtp, dir.'/**/*.vim')
 658     endfor
 659     if a:0
 660       if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2))
 661         execute 'runtime' a:1
 662       endif
 663       call s:source(rtp, a:2)
 664     endif
 665     call s:doautocmd('User', name)
 666   endfor
 667 endfunction
 668
 669 function! s:lod_ft(pat, names)
 670   let syn = 'syntax/'.a:pat.'.vim'
 671   call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn)
 672   execute 'autocmd! PlugLOD FileType' a:pat
 673   call s:doautocmd('filetypeplugin', 'FileType')
 674   call s:doautocmd('filetypeindent', 'FileType')
 675 endfunction
 676
 677 function! s:lod_cmd(cmd, bang, l1, l2, args, names)
 678   call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 679   call s:dobufread(a:names)
 680   execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args)
 681 endfunction
 682
 683 function! s:lod_map(map, names, with_prefix, prefix)
 684   call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 685   call s:dobufread(a:names)
 686   let extra = ''
 687   while 1
 688     let c = getchar(0)
 689     if c == 0
 690       break
 691     endif
 692     let extra .= nr2char(c)
 693   endwhile
 694
 695   if a:with_prefix
 696     let prefix = v:count ? v:count : ''
 697     let prefix .= '"'.v:register.a:prefix
 698     if mode(1) == 'no'
 699       if v:operator == 'c'
 700         let prefix = "\<esc>" . prefix
 701       endif
 702       let prefix .= v:operator
 703     endif
 704     call feedkeys(prefix, 'n')
 705   endif
 706   call feedkeys(substitute(a:map, '^<Plug>', "\<Plug>", '') . extra)
 707 endfunction
 708
 709 function! plug#(repo, ...)
 710   if a:0 > 1
 711     return s:err('Invalid number of arguments (1..2)')
 712   endif
 713
 714   try
 715     let repo = s:trim(a:repo)
 716     let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec
 717     let name = get(opts, 'as', s:plug_fnamemodify(repo, ':t:s?\.git$??'))
 718     let spec = extend(s:infer_properties(name, repo), opts)
 719     if !has_key(g:plugs, name)
 720       call add(g:plugs_order, name)
 721     endif
 722     let g:plugs[name] = spec
 723     let s:loaded[name] = get(s:loaded, name, 0)
 724   catch
 725     return s:err(repo . ' ' . v:exception)
 726   endtry
 727 endfunction
 728
 729 function! s:parse_options(arg)
 730   let opts = copy(s:base_spec)
 731   let type = type(a:arg)
 732   let opt_errfmt = 'Invalid argument for "%s" option of :Plug (expected: %s)'
 733   if type == s:TYPE.string
 734     if empty(a:arg)
 735       throw printf(opt_errfmt, 'tag', 'string')
 736     endif
 737     let opts.tag = a:arg
 738   elseif type == s:TYPE.dict
 739     for opt in ['branch', 'tag', 'commit', 'rtp', 'dir', 'as']
 740       if has_key(a:arg, opt)
 741       \ && (type(a:arg[opt]) != s:TYPE.string || empty(a:arg[opt]))
 742         throw printf(opt_errfmt, opt, 'string')
 743       endif
 744     endfor
 745     for opt in ['on', 'for']
 746       if has_key(a:arg, opt)
 747       \ && type(a:arg[opt]) != s:TYPE.list
 748       \ && (type(a:arg[opt]) != s:TYPE.string || empty(a:arg[opt]))
 749         throw printf(opt_errfmt, opt, 'string or list')
 750       endif
 751     endfor
 752     if has_key(a:arg, 'do')
 753       \ && type(a:arg.do) != s:TYPE.funcref
 754       \ && (type(a:arg.do) != s:TYPE.string || empty(a:arg.do))
 755         throw printf(opt_errfmt, 'do', 'string or funcref')
 756     endif
 757     call extend(opts, a:arg)
 758     if has_key(opts, 'dir')
 759       let opts.dir = s:dirpath(s:plug_expand(opts.dir))
 760     endif
 761   else
 762     throw 'Invalid argument type (expected: string or dictionary)'
 763   endif
 764   return opts
 765 endfunction
 766
 767 function! s:infer_properties(name, repo)
 768   let repo = a:repo
 769   if s:is_local_plug(repo)
 770     return { 'dir': s:dirpath(s:plug_expand(repo)) }
 771   else
 772     if repo =~ ':'
 773       let uri = repo
 774     else
 775       if repo !~ '/'
 776         throw printf('Invalid argument: %s (implicit `vim-scripts'' expansion is deprecated)', repo)
 777       endif
 778       let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git')
 779       let uri = printf(fmt, repo)
 780     endif
 781     return { 'dir': s:dirpath(g:plug_home.'/'.a:name), 'uri': uri }
 782   endif
 783 endfunction
 784
 785 function! s:install(force, names)
 786   call s:update_impl(0, a:force, a:names)
 787 endfunction
 788
 789 function! s:update(force, names)
 790   call s:update_impl(1, a:force, a:names)
 791 endfunction
 792
 793 function! plug#helptags()
 794   if !exists('g:plugs')
 795     return s:err('plug#begin was not called')
 796   endif
 797   for spec in values(g:plugs)
 798     let docd = join([s:rtp(spec), 'doc'], '/')
 799     if isdirectory(docd)
 800       silent! execute 'helptags' s:esc(docd)
 801     endif
 802   endfor
 803   return 1
 804 endfunction
 805
 806 function! s:syntax()
 807   syntax clear
 808   syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber
 809   syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX
 810   syn match plugNumber /[0-9]\+[0-9.]*/ contained
 811   syn match plugBracket /[[\]]/ contained
 812   syn match plugX /x/ contained
 813   syn match plugDash /^-\{1}\ /
 814   syn match plugPlus /^+/
 815   syn match plugStar /^*/
 816   syn match plugMessage /\(^- \)\@<=.*/
 817   syn match plugName /\(^- \)\@<=[^ ]*:/
 818   syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/
 819   syn match plugTag /(tag: [^)]\+)/
 820   syn match plugInstall /\(^+ \)\@<=[^:]*/
 821   syn match plugUpdate /\(^* \)\@<=[^:]*/
 822   syn match plugCommit /^  \X*[0-9a-f]\{7,9} .*/ contains=plugRelDate,plugEdge,plugTag
 823   syn match plugEdge /^  \X\+$/
 824   syn match plugEdge /^  \X*/ contained nextgroup=plugSha
 825   syn match plugSha /[0-9a-f]\{7,9}/ contained
 826   syn match plugRelDate /([^)]*)$/ contained
 827   syn match plugNotLoaded /(not loaded)$/
 828   syn match plugError /^x.*/
 829   syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/
 830   syn match plugH2 /^.*:\n-\+$/
 831   syn match plugH2 /^-\{2,}/
 832   syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean
 833   hi def link plug1       Title
 834   hi def link plug2       Repeat
 835   hi def link plugH2      Type
 836   hi def link plugX       Exception
 837   hi def link plugBracket Structure
 838   hi def link plugNumber  Number
 839
 840   hi def link plugDash    Special
 841   hi def link plugPlus    Constant
 842   hi def link plugStar    Boolean
 843
 844   hi def link plugMessage Function
 845   hi def link plugName    Label
 846   hi def link plugInstall Function
 847   hi def link plugUpdate  Type
 848
 849   hi def link plugError   Error
 850   hi def link plugDeleted Ignore
 851   hi def link plugRelDate Comment
 852   hi def link plugEdge    PreProc
 853   hi def link plugSha     Identifier
 854   hi def link plugTag     Constant
 855
 856   hi def link plugNotLoaded Comment
 857 endfunction
 858
 859 function! s:lpad(str, len)
 860   return a:str . repeat(' ', a:len - len(a:str))
 861 endfunction
 862
 863 function! s:lines(msg)
 864   return split(a:msg, "[\r\n]")
 865 endfunction
 866
 867 function! s:lastline(msg)
 868   return get(s:lines(a:msg), -1, '')
 869 endfunction
 870
 871 function! s:new_window()
 872   execute get(g:, 'plug_window', 'vertical topleft new')
 873 endfunction
 874
 875 function! s:plug_window_exists()
 876   let buflist = tabpagebuflist(s:plug_tab)
 877   return !empty(buflist) && index(buflist, s:plug_buf) >= 0
 878 endfunction
 879
 880 function! s:switch_in()
 881   if !s:plug_window_exists()
 882     return 0
 883   endif
 884
 885   if winbufnr(0) != s:plug_buf
 886     let s:pos = [tabpagenr(), winnr(), winsaveview()]
 887     execute 'normal!' s:plug_tab.'gt'
 888     let winnr = bufwinnr(s:plug_buf)
 889     execute winnr.'wincmd w'
 890     call add(s:pos, winsaveview())
 891   else
 892     let s:pos = [winsaveview()]
 893   endif
 894
 895   setlocal modifiable
 896   return 1
 897 endfunction
 898
 899 function! s:switch_out(...)
 900   call winrestview(s:pos[-1])
 901   setlocal nomodifiable
 902   if a:0 > 0
 903     execute a:1
 904   endif
 905
 906   if len(s:pos) > 1
 907     execute 'normal!' s:pos[0].'gt'
 908     execute s:pos[1] 'wincmd w'
 909     call winrestview(s:pos[2])
 910   endif
 911 endfunction
 912
 913 function! s:finish_bindings()
 914   nnoremap <silent> <buffer> R  :call <SID>retry()<cr>
 915   nnoremap <silent> <buffer> D  :PlugDiff<cr>
 916   nnoremap <silent> <buffer> S  :PlugStatus<cr>
 917   nnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
 918   xnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
 919   nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr>
 920   nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr>
 921 endfunction
 922
 923 function! s:prepare(...)
 924   if empty(s:plug_getcwd())
 925     throw 'Invalid current working directory. Cannot proceed.'
 926   endif
 927
 928   for evar in ['$GIT_DIR', '$GIT_WORK_TREE']
 929     if exists(evar)
 930       throw evar.' detected. Cannot proceed.'
 931     endif
 932   endfor
 933
 934   call s:job_abort()
 935   if s:switch_in()
 936     if b:plug_preview == 1
 937       pc
 938     endif
 939     enew
 940   else
 941     call s:new_window()
 942   endif
 943
 944   nnoremap <silent> <buffer> q :call <SID>close_pane()<cr>
 945   if a:0 == 0
 946     call s:finish_bindings()
 947   endif
 948   let b:plug_preview = -1
 949   let s:plug_tab = tabpagenr()
 950   let s:plug_buf = winbufnr(0)
 951   call s:assign_name()
 952
 953   for k in ['<cr>', 'L', 'o', 'X', 'd', 'dd']
 954     execute 'silent! unmap <buffer>' k
 955   endfor
 956   setlocal buftype=nofile bufhidden=wipe nobuflisted nolist noswapfile nowrap cursorline modifiable nospell
 957   if exists('+colorcolumn')
 958     setlocal colorcolumn=
 959   endif
 960   setf vim-plug
 961   if exists('g:syntax_on')
 962     call s:syntax()
 963   endif
 964 endfunction
 965
 966 function! s:close_pane()
 967   if b:plug_preview == 1
 968     pc
 969     let b:plug_preview = -1
 970   else
 971     bd
 972   endif
 973 endfunction
 974
 975 function! s:assign_name()
 976   " Assign buffer name
 977   let prefix = '[Plugins]'
 978   let name   = prefix
 979   let idx    = 2
 980   while bufexists(name)
 981     let name = printf('%s (%s)', prefix, idx)
 982     let idx = idx + 1
 983   endwhile
 984   silent! execute 'f' fnameescape(name)
 985 endfunction
 986
 987 function! s:chsh(swap)
 988   let prev = [&shell, &shellcmdflag, &shellredir]
 989   if !s:is_win
 990     set shell=sh
 991   endif
 992   if a:swap
 993     if s:is_powershell(&shell)
 994       let &shellredir = '2>&1 | Out-File -Encoding UTF8 %s'
 995     elseif &shell =~# 'sh' || &shell =~# 'cmd\(\.exe\)\?$'
 996       set shellredir=>%s\ 2>&1
 997     endif
 998   endif
 999   return prev
1000 endfunction
1001
1002 function! s:bang(cmd, ...)
1003   let batchfile = ''
1004   try
1005     let [sh, shellcmdflag, shrd] = s:chsh(a:0)
1006     " FIXME: Escaping is incomplete. We could use shellescape with eval,
1007     "        but it won't work on Windows.
1008     let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd
1009     if s:is_win
1010       let [batchfile, cmd] = s:batchfile(cmd)
1011     endif
1012     let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%')
1013     execute "normal! :execute g:_plug_bang\<cr>\<cr>"
1014   finally
1015     unlet g:_plug_bang
1016     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
1017     if s:is_win && filereadable(batchfile)
1018       call delete(batchfile)
1019     endif
1020   endtry
1021   return v:shell_error ? 'Exit status: ' . v:shell_error : ''
1022 endfunction
1023
1024 function! s:regress_bar()
1025   let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '')
1026   call s:progress_bar(2, bar, len(bar))
1027 endfunction
1028
1029 function! s:is_updated(dir)
1030   return !empty(s:system_chomp(['git', 'log', '--pretty=format:%h', 'HEAD...HEAD@{1}'], a:dir))
1031 endfunction
1032
1033 function! s:do(pull, force, todo)
1034   for [name, spec] in items(a:todo)
1035     if !isdirectory(spec.dir)
1036       continue
1037     endif
1038     let installed = has_key(s:update.new, name)
1039     let updated = installed ? 0 :
1040       \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir))
1041     if a:force || installed || updated
1042       execute 'cd' s:esc(spec.dir)
1043       call append(3, '- Post-update hook for '. name .' ... ')
1044       let error = ''
1045       let type = type(spec.do)
1046       if type == s:TYPE.string
1047         if spec.do[0] == ':'
1048           if !get(s:loaded, name, 0)
1049             let s:loaded[name] = 1
1050             call s:reorg_rtp()
1051           endif
1052           call s:load_plugin(spec)
1053           try
1054             execute spec.do[1:]
1055           catch
1056             let error = v:exception
1057           endtry
1058           if !s:plug_window_exists()
1059             cd -
1060             throw 'Warning: vim-plug was terminated by the post-update hook of '.name
1061           endif
1062         else
1063           let error = s:bang(spec.do)
1064         endif
1065       elseif type == s:TYPE.funcref
1066         try
1067           call s:load_plugin(spec)
1068           let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged')
1069           call spec.do({ 'name': name, 'status': status, 'force': a:force })
1070         catch
1071           let error = v:exception
1072         endtry
1073       else
1074         let error = 'Invalid hook type'
1075       endif
1076       call s:switch_in()
1077       call setline(4, empty(error) ? (getline(4) . 'OK')
1078                                  \ : ('x' . getline(4)[1:] . error))
1079       if !empty(error)
1080         call add(s:update.errors, name)
1081         call s:regress_bar()
1082       endif
1083       cd -
1084     endif
1085   endfor
1086 endfunction
1087
1088 function! s:hash_match(a, b)
1089   return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0
1090 endfunction
1091
1092 function! s:checkout(spec)
1093   let sha = a:spec.commit
1094   let output = s:git_revision(a:spec.dir)
1095   if !empty(output) && !s:hash_match(sha, s:lines(output)[0])
1096     let credential_helper = s:git_version_requirement(2) ? '-c credential.helper= ' : ''
1097     let output = s:system(
1098           \ 'git '.credential_helper.'fetch --depth 999999 && git checkout '.plug#shellescape(sha).' --', a:spec.dir)
1099   endif
1100   return output
1101 endfunction
1102
1103 function! s:finish(pull)
1104   let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen'))
1105   if new_frozen
1106     let s = new_frozen > 1 ? 's' : ''
1107     call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s))
1108   endif
1109   call append(3, '- Finishing ... ') | 4
1110   redraw
1111   call plug#helptags()
1112   call plug#end()
1113   call setline(4, getline(4) . 'Done!')
1114   redraw
1115   let msgs = []
1116   if !empty(s:update.errors)
1117     call add(msgs, "Press 'R' to retry.")
1118   endif
1119   if a:pull && len(s:update.new) < len(filter(getline(5, '$'),
1120                 \ "v:val =~ '^- ' && v:val !~# 'Already up.to.date'"))
1121     call add(msgs, "Press 'D' to see the updated changes.")
1122   endif
1123   echo join(msgs, ' ')
1124   call s:finish_bindings()
1125 endfunction
1126
1127 function! s:retry()
1128   if empty(s:update.errors)
1129     return
1130   endif
1131   echo
1132   call s:update_impl(s:update.pull, s:update.force,
1133         \ extend(copy(s:update.errors), [s:update.threads]))
1134 endfunction
1135
1136 function! s:is_managed(name)
1137   return has_key(g:plugs[a:name], 'uri')
1138 endfunction
1139
1140 function! s:names(...)
1141   return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)'))
1142 endfunction
1143
1144 function! s:check_ruby()
1145   silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'")
1146   if !exists('g:plug_ruby')
1147     redraw!
1148     return s:warn('echom', 'Warning: Ruby interface is broken')
1149   endif
1150   let ruby_version = split(g:plug_ruby, '\.')
1151   unlet g:plug_ruby
1152   return s:version_requirement(ruby_version, [1, 8, 7])
1153 endfunction
1154
1155 function! s:update_impl(pull, force, args) abort
1156   let sync = index(a:args, '--sync') >= 0 || has('vim_starting')
1157   let args = filter(copy(a:args), 'v:val != "--sync"')
1158   let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?
1159                   \ remove(args, -1) : get(g:, 'plug_threads', 16)
1160
1161   let managed = filter(copy(g:plugs), 's:is_managed(v:key)')
1162   let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :
1163                          \ filter(managed, 'index(args, v:key) >= 0')
1164
1165   if empty(todo)
1166     return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install'))
1167   endif
1168
1169   if !s:is_win && s:git_version_requirement(2, 3)
1170     let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : ''
1171     let $GIT_TERMINAL_PROMPT = 0
1172     for plug in values(todo)
1173       let plug.uri = substitute(plug.uri,
1174             \ '^https://git::@github\.com', 'https://github.com', '')
1175     endfor
1176   endif
1177
1178   if !isdirectory(g:plug_home)
1179     try
1180       call mkdir(g:plug_home, 'p')
1181     catch
1182       return s:err(printf('Invalid plug directory: %s. '.
1183               \ 'Try to call plug#begin with a valid directory', g:plug_home))
1184     endtry
1185   endif
1186
1187   if has('nvim') && !exists('*jobwait') && threads > 1
1188     call s:warn('echom', '[vim-plug] Update Neovim for parallel installer')
1189   endif
1190
1191   let use_job = s:nvim || s:vim8
1192   let python = (has('python') || has('python3')) && !use_job
1193   let ruby = has('ruby') && !use_job && (v:version >= 703 || v:version == 702 && has('patch374')) && !(s:is_win && has('gui_running')) && threads > 1 && s:check_ruby()
1194
1195   let s:update = {
1196     \ 'start':   reltime(),
1197     \ 'all':     todo,
1198     \ 'todo':    copy(todo),
1199     \ 'errors':  [],
1200     \ 'pull':    a:pull,
1201     \ 'force':   a:force,
1202     \ 'new':     {},
1203     \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1,
1204     \ 'bar':     '',
1205     \ 'fin':     0
1206   \ }
1207
1208   call s:prepare(1)
1209   call append(0, ['', ''])
1210   normal! 2G
1211   silent! redraw
1212
1213   " Set remote name, overriding a possible user git config's clone.defaultRemoteName
1214   let s:clone_opt = ['--origin', 'origin']
1215   if get(g:, 'plug_shallow', 1)
1216     call extend(s:clone_opt, ['--depth', '1'])
1217     if s:git_version_requirement(1, 7, 10)
1218       call add(s:clone_opt, '--no-single-branch')
1219     endif
1220   endif
1221
1222   if has('win32unix') || has('wsl')
1223     call extend(s:clone_opt, ['-c', 'core.eol=lf', '-c', 'core.autocrlf=input'])
1224   endif
1225
1226   let s:submodule_opt = s:git_version_requirement(2, 8) ? ' --jobs='.threads : ''
1227
1228   " Python version requirement (>= 2.7)
1229   if python && !has('python3') && !ruby && !use_job && s:update.threads > 1
1230     redir => pyv
1231     silent python import platform; print platform.python_version()
1232     redir END
1233     let python = s:version_requirement(
1234           \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6])
1235   endif
1236
1237   if (python || ruby) && s:update.threads > 1
1238     try
1239       let imd = &imd
1240       if s:mac_gui
1241         set noimd
1242       endif
1243       if ruby
1244         call s:update_ruby()
1245       else
1246         call s:update_python()
1247       endif
1248     catch
1249       let lines = getline(4, '$')
1250       let printed = {}
1251       silent! 4,$d _
1252       for line in lines
1253         let name = s:extract_name(line, '.', '')
1254         if empty(name) || !has_key(printed, name)
1255           call append('$', line)
1256           if !empty(name)
1257             let printed[name] = 1
1258             if line[0] == 'x' && index(s:update.errors, name) < 0
1259               call add(s:update.errors, name)
1260             end
1261           endif
1262         endif
1263       endfor
1264     finally
1265       let &imd = imd
1266       call s:update_finish()
1267     endtry
1268   else
1269     call s:update_vim()
1270     while use_job && sync
1271       sleep 100m
1272       if s:update.fin
1273         break
1274       endif
1275     endwhile
1276   endif
1277 endfunction
1278
1279 function! s:log4(name, msg)
1280   call setline(4, printf('- %s (%s)', a:msg, a:name))
1281   redraw
1282 endfunction
1283
1284 function! s:update_finish()
1285   if exists('s:git_terminal_prompt')
1286     let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt
1287   endif
1288   if s:switch_in()
1289     call append(3, '- Updating ...') | 4
1290     for [name, spec] in items(filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && (s:update.force || s:update.pull || has_key(s:update.new, v:key))'))
1291       let [pos, _] = s:logpos(name)
1292       if !pos
1293         continue
1294       endif
1295       if has_key(spec, 'commit')
1296         call s:log4(name, 'Checking out '.spec.commit)
1297         let out = s:checkout(spec)
1298       elseif has_key(spec, 'tag')
1299         let tag = spec.tag
1300         if tag =~ '\*'
1301           let tags = s:lines(s:system('git tag --list '.plug#shellescape(tag).' --sort -version:refname 2>&1', spec.dir))
1302           if !v:shell_error && !empty(tags)
1303             let tag = tags[0]
1304             call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag))
1305             call append(3, '')
1306           endif
1307         endif
1308         call s:log4(name, 'Checking out '.tag)
1309         let out = s:system('git checkout -q '.plug#shellescape(tag).' -- 2>&1', spec.dir)
1310       else
1311         let branch = s:git_origin_branch(spec)
1312         call s:log4(name, 'Merging origin/'.s:esc(branch))
1313         let out = s:system('git checkout -q '.plug#shellescape(branch).' -- 2>&1'
1314               \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only '.plug#shellescape('origin/'.branch).' 2>&1')), spec.dir)
1315       endif
1316       if !v:shell_error && filereadable(spec.dir.'/.gitmodules') &&
1317             \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir))
1318         call s:log4(name, 'Updating submodules. This may take a while.')
1319         let out .= s:bang('git submodule update --init --recursive'.s:submodule_opt.' 2>&1', spec.dir)
1320       endif
1321       let msg = s:format_message(v:shell_error ? 'x': '-', name, out)
1322       if v:shell_error
1323         call add(s:update.errors, name)
1324         call s:regress_bar()
1325         silent execute pos 'd _'
1326         call append(4, msg) | 4
1327       elseif !empty(out)
1328         call setline(pos, msg[0])
1329       endif
1330       redraw
1331     endfor
1332     silent 4 d _
1333     try
1334       call s:do(s:update.pull, s:update.force, filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && has_key(v:val, "do")'))
1335     catch
1336       call s:warn('echom', v:exception)
1337       call s:warn('echo', '')
1338       return
1339     endtry
1340     call s:finish(s:update.pull)
1341     call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.')
1342     call s:switch_out('normal! gg')
1343   endif
1344 endfunction
1345
1346 function! s:job_abort()
1347   if (!s:nvim && !s:vim8) || !exists('s:jobs')
1348     return
1349   endif
1350
1351   for [name, j] in items(s:jobs)
1352     if s:nvim
1353       silent! call jobstop(j.jobid)
1354     elseif s:vim8
1355       silent! call job_stop(j.jobid)
1356     endif
1357     if j.new
1358       call s:rm_rf(g:plugs[name].dir)
1359     endif
1360   endfor
1361   let s:jobs = {}
1362 endfunction
1363
1364 function! s:last_non_empty_line(lines)
1365   let len = len(a:lines)
1366   for idx in range(len)
1367     let line = a:lines[len-idx-1]
1368     if !empty(line)
1369       return line
1370     endif
1371   endfor
1372   return ''
1373 endfunction
1374
1375 function! s:job_out_cb(self, data) abort
1376   let self = a:self
1377   let data = remove(self.lines, -1) . a:data
1378   let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]')
1379   call extend(self.lines, lines)
1380   " To reduce the number of buffer updates
1381   let self.tick = get(self, 'tick', -1) + 1
1382   if !self.running || self.tick % len(s:jobs) == 0
1383     let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-')
1384     let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines)
1385     call s:log(bullet, self.name, result)
1386   endif
1387 endfunction
1388
1389 function! s:job_exit_cb(self, data) abort
1390   let a:self.running = 0
1391   let a:self.error = a:data != 0
1392   call s:reap(a:self.name)
1393   call s:tick()
1394 endfunction
1395
1396 function! s:job_cb(fn, job, ch, data)
1397   if !s:plug_window_exists() " plug window closed
1398     return s:job_abort()
1399   endif
1400   call call(a:fn, [a:job, a:data])
1401 endfunction
1402
1403 function! s:nvim_cb(job_id, data, event) dict abort
1404   return (a:event == 'stdout' || a:event == 'stderr') ?
1405     \ s:job_cb('s:job_out_cb',  self, 0, join(a:data, "\n")) :
1406     \ s:job_cb('s:job_exit_cb', self, 0, a:data)
1407 endfunction
1408
1409 function! s:spawn(name, cmd, opts)
1410   let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''],
1411             \ 'new': get(a:opts, 'new', 0) }
1412   let s:jobs[a:name] = job
1413
1414   if s:nvim
1415     if has_key(a:opts, 'dir')
1416       let job.cwd = a:opts.dir
1417     endif
1418     let argv = a:cmd
1419     call extend(job, {
1420     \ 'on_stdout': function('s:nvim_cb'),
1421     \ 'on_stderr': function('s:nvim_cb'),
1422     \ 'on_exit':   function('s:nvim_cb'),
1423     \ })
1424     let jid = s:plug_call('jobstart', argv, job)
1425     if jid > 0
1426       let job.jobid = jid
1427     else
1428       let job.running = 0
1429       let job.error   = 1
1430       let job.lines   = [jid < 0 ? argv[0].' is not executable' :
1431             \ 'Invalid arguments (or job table is full)']
1432     endif
1433   elseif s:vim8
1434     let cmd = join(map(copy(a:cmd), 'plug#shellescape(v:val, {"script": 0})'))
1435     if has_key(a:opts, 'dir')
1436       let cmd = s:with_cd(cmd, a:opts.dir, 0)
1437     endif
1438     let argv = s:is_win ? ['cmd', '/s', '/c', '"'.cmd.'"'] : ['sh', '-c', cmd]
1439     let jid = job_start(s:is_win ? join(argv, ' ') : argv, {
1440     \ 'out_cb':   function('s:job_cb', ['s:job_out_cb',  job]),
1441     \ 'err_cb':   function('s:job_cb', ['s:job_out_cb',  job]),
1442     \ 'exit_cb':  function('s:job_cb', ['s:job_exit_cb', job]),
1443     \ 'err_mode': 'raw',
1444     \ 'out_mode': 'raw'
1445     \})
1446     if job_status(jid) == 'run'
1447       let job.jobid = jid
1448     else
1449       let job.running = 0
1450       let job.error   = 1
1451       let job.lines   = ['Failed to start job']
1452     endif
1453   else
1454     let job.lines = s:lines(call('s:system', has_key(a:opts, 'dir') ? [a:cmd, a:opts.dir] : [a:cmd]))
1455     let job.error = v:shell_error != 0
1456     let job.running = 0
1457   endif
1458 endfunction
1459
1460 function! s:reap(name)
1461   let job = s:jobs[a:name]
1462   if job.error
1463     call add(s:update.errors, a:name)
1464   elseif get(job, 'new', 0)
1465     let s:update.new[a:name] = 1
1466   endif
1467   let s:update.bar .= job.error ? 'x' : '='
1468
1469   let bullet = job.error ? 'x' : '-'
1470   let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines)
1471   call s:log(bullet, a:name, empty(result) ? 'OK' : result)
1472   call s:bar()
1473
1474   call remove(s:jobs, a:name)
1475 endfunction
1476
1477 function! s:bar()
1478   if s:switch_in()
1479     let total = len(s:update.all)
1480     call setline(1, (s:update.pull ? 'Updating' : 'Installing').
1481           \ ' plugins ('.len(s:update.bar).'/'.total.')')
1482     call s:progress_bar(2, s:update.bar, total)
1483     call s:switch_out()
1484   endif
1485 endfunction
1486
1487 function! s:logpos(name)
1488   let max = line('$')
1489   for i in range(4, max > 4 ? max : 4)
1490     if getline(i) =~# '^[-+x*] '.a:name.':'
1491       for j in range(i + 1, max > 5 ? max : 5)
1492         if getline(j) !~ '^ '
1493           return [i, j - 1]
1494         endif
1495       endfor
1496       return [i, i]
1497     endif
1498   endfor
1499   return [0, 0]
1500 endfunction
1501
1502 function! s:log(bullet, name, lines)
1503   if s:switch_in()
1504     let [b, e] = s:logpos(a:name)
1505     if b > 0
1506       silent execute printf('%d,%d d _', b, e)
1507       if b > winheight('.')
1508         let b = 4
1509       endif
1510     else
1511       let b = 4
1512     endif
1513     " FIXME For some reason, nomodifiable is set after :d in vim8
1514     setlocal modifiable
1515     call append(b - 1, s:format_message(a:bullet, a:name, a:lines))
1516     call s:switch_out()
1517   endif
1518 endfunction
1519
1520 function! s:update_vim()
1521   let s:jobs = {}
1522
1523   call s:bar()
1524   call s:tick()
1525 endfunction
1526
1527 function! s:tick()
1528   let pull = s:update.pull
1529   let prog = s:progress_opt(s:nvim || s:vim8)
1530 while 1 " Without TCO, Vim stack is bound to explode
1531   if empty(s:update.todo)
1532     if empty(s:jobs) && !s:update.fin
1533       call s:update_finish()
1534       let s:update.fin = 1
1535     endif
1536     return
1537   endif
1538
1539   let name = keys(s:update.todo)[0]
1540   let spec = remove(s:update.todo, name)
1541   let new  = empty(globpath(spec.dir, '.git', 1))
1542
1543   call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
1544   redraw
1545
1546   let has_tag = has_key(spec, 'tag')
1547   if !new
1548     let [error, _] = s:git_validate(spec, 0)
1549     if empty(error)
1550       if pull
1551         let cmd = s:git_version_requirement(2) ? ['git', '-c', 'credential.helper=', 'fetch'] : ['git', 'fetch']
1552         if has_tag && !empty(globpath(spec.dir, '.git/shallow'))
1553           call extend(cmd, ['--depth', '99999999'])
1554         endif
1555         if !empty(prog)
1556           call add(cmd, prog)
1557         endif
1558         call s:spawn(name, cmd, { 'dir': spec.dir })
1559       else
1560         let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 }
1561       endif
1562     else
1563       let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 }
1564     endif
1565   else
1566     let cmd = ['git', 'clone']
1567     if !has_tag
1568       call extend(cmd, s:clone_opt)
1569     endif
1570     if !empty(prog)
1571       call add(cmd, prog)
1572     endif
1573     call s:spawn(name, extend(cmd, [spec.uri, s:trim(spec.dir)]), { 'new': 1 })
1574   endif
1575
1576   if !s:jobs[name].running
1577     call s:reap(name)
1578   endif
1579   if len(s:jobs) >= s:update.threads
1580     break
1581   endif
1582 endwhile
1583 endfunction
1584
1585 function! s:update_python()
1586 let py_exe = has('python') ? 'python' : 'python3'
1587 execute py_exe "<< EOF"
1588 import datetime
1589 import functools
1590 import os
1591 try:
1592   import queue
1593 except ImportError:
1594   import Queue as queue
1595 import random
1596 import re
1597 import shutil
1598 import signal
1599 import subprocess
1600 import tempfile
1601 import threading as thr
1602 import time
1603 import traceback
1604 import vim
1605
1606 G_NVIM = vim.eval("has('nvim')") == '1'
1607 G_PULL = vim.eval('s:update.pull') == '1'
1608 G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1
1609 G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)'))
1610 G_CLONE_OPT = ' '.join(vim.eval('s:clone_opt'))
1611 G_PROGRESS = vim.eval('s:progress_opt(1)')
1612 G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads'))
1613 G_STOP = thr.Event()
1614 G_IS_WIN = vim.eval('s:is_win') == '1'
1615
1616 class PlugError(Exception):
1617   def __init__(self, msg):
1618     self.msg = msg
1619 class CmdTimedOut(PlugError):
1620   pass
1621 class CmdFailed(PlugError):
1622   pass
1623 class InvalidURI(PlugError):
1624   pass
1625 class Action(object):
1626   INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-']
1627
1628 class Buffer(object):
1629   def __init__(self, lock, num_plugs, is_pull):
1630     self.bar = ''
1631     self.event = 'Updating' if is_pull else 'Installing'
1632     self.lock = lock
1633     self.maxy = int(vim.eval('winheight(".")'))
1634     self.num_plugs = num_plugs
1635
1636   def __where(self, name):
1637     """ Find first line with name in current buffer. Return line num. """
1638     found, lnum = False, 0
1639     matcher = re.compile('^[-+x*] {0}:'.format(name))
1640     for line in vim.current.buffer:
1641       if matcher.search(line) is not None:
1642         found = True
1643         break
1644       lnum += 1
1645
1646     if not found:
1647       lnum = -1
1648     return lnum
1649
1650   def header(self):
1651     curbuf = vim.current.buffer
1652     curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs)
1653
1654     num_spaces = self.num_plugs - len(self.bar)
1655     curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ')
1656
1657     with self.lock:
1658       vim.command('normal! 2G')
1659       vim.command('redraw')
1660
1661   def write(self, action, name, lines):
1662     first, rest = lines[0], lines[1:]
1663     msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)]
1664     msg.extend(['    ' + line for line in rest])
1665
1666     try:
1667       if action == Action.ERROR:
1668         self.bar += 'x'
1669         vim.command("call add(s:update.errors, '{0}')".format(name))
1670       elif action == Action.DONE:
1671         self.bar += '='
1672
1673       curbuf = vim.current.buffer
1674       lnum = self.__where(name)
1675       if lnum != -1: # Found matching line num
1676         del curbuf[lnum]
1677         if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]):
1678           lnum = 3
1679       else:
1680         lnum = 3
1681       curbuf.append(msg, lnum)
1682
1683       self.header()
1684     except vim.error:
1685       pass
1686
1687 class Command(object):
1688   CD = 'cd /d' if G_IS_WIN else 'cd'
1689
1690   def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None):
1691     self.cmd = cmd
1692     if cmd_dir:
1693       self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd)
1694     self.timeout = timeout
1695     self.callback = cb if cb else (lambda msg: None)
1696     self.clean = clean if clean else (lambda: None)
1697     self.proc = None
1698
1699   @property
1700   def alive(self):
1701     """ Returns true only if command still running. """
1702     return self.proc and self.proc.poll() is None
1703
1704   def execute(self, ntries=3):
1705     """ Execute the command with ntries if CmdTimedOut.
1706         Returns the output of the command if no Exception.
1707     """
1708     attempt, finished, limit = 0, False, self.timeout
1709
1710     while not finished:
1711       try:
1712         attempt += 1
1713         result = self.try_command()
1714         finished = True
1715         return result
1716       except CmdTimedOut:
1717         if attempt != ntries:
1718           self.notify_retry()
1719           self.timeout += limit
1720         else:
1721           raise
1722
1723   def notify_retry(self):
1724     """ Retry required for command, notify user. """
1725     for count in range(3, 0, -1):
1726       if G_STOP.is_set():
1727         raise KeyboardInterrupt
1728       msg = 'Timeout. Will retry in {0} second{1} ...'.format(
1729             count, 's' if count != 1 else '')
1730       self.callback([msg])
1731       time.sleep(1)
1732     self.callback(['Retrying ...'])
1733
1734   def try_command(self):
1735     """ Execute a cmd & poll for callback. Returns list of output.
1736         Raises CmdFailed   -> return code for Popen isn't 0
1737         Raises CmdTimedOut -> command exceeded timeout without new output
1738     """
1739     first_line = True
1740
1741     try:
1742       tfile = tempfile.NamedTemporaryFile(mode='w+b')
1743       preexec_fn = not G_IS_WIN and os.setsid or None
1744       self.proc = subprocess.Popen(self.cmd, stdout=tfile,
1745                                    stderr=subprocess.STDOUT,
1746                                    stdin=subprocess.PIPE, shell=True,
1747                                    preexec_fn=preexec_fn)
1748       thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,))
1749       thrd.start()
1750
1751       thread_not_started = True
1752       while thread_not_started:
1753         try:
1754           thrd.join(0.1)
1755           thread_not_started = False
1756         except RuntimeError:
1757           pass
1758
1759       while self.alive:
1760         if G_STOP.is_set():
1761           raise KeyboardInterrupt
1762
1763         if first_line or random.random() < G_LOG_PROB:
1764           first_line = False
1765           line = '' if G_IS_WIN else nonblock_read(tfile.name)
1766           if line:
1767             self.callback([line])
1768
1769         time_diff = time.time() - os.path.getmtime(tfile.name)
1770         if time_diff > self.timeout:
1771           raise CmdTimedOut(['Timeout!'])
1772
1773         thrd.join(0.5)
1774
1775       tfile.seek(0)
1776       result = [line.decode('utf-8', 'replace').rstrip() for line in tfile]
1777
1778       if self.proc.returncode != 0:
1779         raise CmdFailed([''] + result)
1780
1781       return result
1782     except:
1783       self.terminate()
1784       raise
1785
1786   def terminate(self):
1787     """ Terminate process and cleanup. """
1788     if self.alive:
1789       if G_IS_WIN:
1790         os.kill(self.proc.pid, signal.SIGINT)
1791       else:
1792         os.killpg(self.proc.pid, signal.SIGTERM)
1793     self.clean()
1794
1795 class Plugin(object):
1796   def __init__(self, name, args, buf_q, lock):
1797     self.name = name
1798     self.args = args
1799     self.buf_q = buf_q
1800     self.lock = lock
1801     self.tag = args.get('tag', 0)
1802
1803   def manage(self):
1804     try:
1805       if os.path.exists(self.args['dir']):
1806         self.update()
1807       else:
1808         self.install()
1809         with self.lock:
1810           thread_vim_command("let s:update.new['{0}'] = 1".format(self.name))
1811     except PlugError as exc:
1812       self.write(Action.ERROR, self.name, exc.msg)
1813     except KeyboardInterrupt:
1814       G_STOP.set()
1815       self.write(Action.ERROR, self.name, ['Interrupted!'])
1816     except:
1817       # Any exception except those above print stack trace
1818       msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip())
1819       self.write(Action.ERROR, self.name, msg.split('\n'))
1820       raise
1821
1822   def install(self):
1823     target = self.args['dir']
1824     if target[-1] == '\\':
1825       target = target[0:-1]
1826
1827     def clean(target):
1828       def _clean():
1829         try:
1830           shutil.rmtree(target)
1831         except OSError:
1832           pass
1833       return _clean
1834
1835     self.write(Action.INSTALL, self.name, ['Installing ...'])
1836     callback = functools.partial(self.write, Action.INSTALL, self.name)
1837     cmd = 'git clone {0} {1} {2} {3} 2>&1'.format(
1838           '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'],
1839           esc(target))
1840     com = Command(cmd, None, G_TIMEOUT, callback, clean(target))
1841     result = com.execute(G_RETRIES)
1842     self.write(Action.DONE, self.name, result[-1:])
1843
1844   def repo_uri(self):
1845     cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url'
1846     command = Command(cmd, self.args['dir'], G_TIMEOUT,)
1847     result = command.execute(G_RETRIES)
1848     return result[-1]
1849
1850   def update(self):
1851     actual_uri = self.repo_uri()
1852     expect_uri = self.args['uri']
1853     regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$')
1854     ma = regex.match(actual_uri)
1855     mb = regex.match(expect_uri)
1856     if ma is None or mb is None or ma.groups() != mb.groups():
1857       msg = ['',
1858              'Invalid URI: {0}'.format(actual_uri),
1859              'Expected     {0}'.format(expect_uri),
1860              'PlugClean required.']
1861       raise InvalidURI(msg)
1862
1863     if G_PULL:
1864       self.write(Action.UPDATE, self.name, ['Updating ...'])
1865       callback = functools.partial(self.write, Action.UPDATE, self.name)
1866       fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else ''
1867       cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS)
1868       com = Command(cmd, self.args['dir'], G_TIMEOUT, callback)
1869       result = com.execute(G_RETRIES)
1870       self.write(Action.DONE, self.name, result[-1:])
1871     else:
1872       self.write(Action.DONE, self.name, ['Already installed'])
1873
1874   def write(self, action, name, msg):
1875     self.buf_q.put((action, name, msg))
1876
1877 class PlugThread(thr.Thread):
1878   def __init__(self, tname, args):
1879     super(PlugThread, self).__init__()
1880     self.tname = tname
1881     self.args = args
1882
1883   def run(self):
1884     thr.current_thread().name = self.tname
1885     buf_q, work_q, lock = self.args
1886
1887     try:
1888       while not G_STOP.is_set():
1889         name, args = work_q.get_nowait()
1890         plug = Plugin(name, args, buf_q, lock)
1891         plug.manage()
1892         work_q.task_done()
1893     except queue.Empty:
1894       pass
1895
1896 class RefreshThread(thr.Thread):
1897   def __init__(self, lock):
1898     super(RefreshThread, self).__init__()
1899     self.lock = lock
1900     self.running = True
1901
1902   def run(self):
1903     while self.running:
1904       with self.lock:
1905         thread_vim_command('noautocmd normal! a')
1906       time.sleep(0.33)
1907
1908   def stop(self):
1909     self.running = False
1910
1911 if G_NVIM:
1912   def thread_vim_command(cmd):
1913     vim.session.threadsafe_call(lambda: vim.command(cmd))
1914 else:
1915   def thread_vim_command(cmd):
1916     vim.command(cmd)
1917
1918 def esc(name):
1919   return '"' + name.replace('"', '\"') + '"'
1920
1921 def nonblock_read(fname):
1922   """ Read a file with nonblock flag. Return the last line. """
1923   fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK)
1924   buf = os.read(fread, 100000).decode('utf-8', 'replace')
1925   os.close(fread)
1926
1927   line = buf.rstrip('\r\n')
1928   left = max(line.rfind('\r'), line.rfind('\n'))
1929   if left != -1:
1930     left += 1
1931     line = line[left:]
1932
1933   return line
1934
1935 def main():
1936   thr.current_thread().name = 'main'
1937   nthreads = int(vim.eval('s:update.threads'))
1938   plugs = vim.eval('s:update.todo')
1939   mac_gui = vim.eval('s:mac_gui') == '1'
1940
1941   lock = thr.Lock()
1942   buf = Buffer(lock, len(plugs), G_PULL)
1943   buf_q, work_q = queue.Queue(), queue.Queue()
1944   for work in plugs.items():
1945     work_q.put(work)
1946
1947   start_cnt = thr.active_count()
1948   for num in range(nthreads):
1949     tname = 'PlugT-{0:02}'.format(num)
1950     thread = PlugThread(tname, (buf_q, work_q, lock))
1951     thread.start()
1952   if mac_gui:
1953     rthread = RefreshThread(lock)
1954     rthread.start()
1955
1956   while not buf_q.empty() or thr.active_count() != start_cnt:
1957     try:
1958       action, name, msg = buf_q.get(True, 0.25)
1959       buf.write(action, name, ['OK'] if not msg else msg)
1960       buf_q.task_done()
1961     except queue.Empty:
1962       pass
1963     except KeyboardInterrupt:
1964       G_STOP.set()
1965
1966   if mac_gui:
1967     rthread.stop()
1968     rthread.join()
1969
1970 main()
1971 EOF
1972 endfunction
1973
1974 function! s:update_ruby()
1975   ruby << EOF
1976   module PlugStream
1977     SEP = ["\r", "\n", nil]
1978     def get_line
1979       buffer = ''
1980       loop do
1981         char = readchar rescue return
1982         if SEP.include? char.chr
1983           buffer << $/
1984           break
1985         else
1986           buffer << char
1987         end
1988       end
1989       buffer
1990     end
1991   end unless defined?(PlugStream)
1992
1993   def esc arg
1994     %["#{arg.gsub('"', '\"')}"]
1995   end
1996
1997   def killall pid
1998     pids = [pid]
1999     if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM
2000       pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil }
2001     else
2002       unless `which pgrep 2> /dev/null`.empty?
2003         children = pids
2004         until children.empty?
2005           children = children.map { |pid|
2006             `pgrep -P #{pid}`.lines.map { |l| l.chomp }
2007           }.flatten
2008           pids += children
2009         end
2010       end
2011       pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil }
2012     end
2013   end
2014
2015   def compare_git_uri a, b
2016     regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$}
2017     regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1)
2018   end
2019
2020   require 'thread'
2021   require 'fileutils'
2022   require 'timeout'
2023   running = true
2024   iswin = VIM::evaluate('s:is_win').to_i == 1
2025   pull  = VIM::evaluate('s:update.pull').to_i == 1
2026   base  = VIM::evaluate('g:plug_home')
2027   all   = VIM::evaluate('s:update.todo')
2028   limit = VIM::evaluate('get(g:, "plug_timeout", 60)')
2029   tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1
2030   nthr  = VIM::evaluate('s:update.threads').to_i
2031   maxy  = VIM::evaluate('winheight(".")').to_i
2032   vim7  = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/
2033   cd    = iswin ? 'cd /d' : 'cd'
2034   tot   = VIM::evaluate('len(s:update.todo)') || 0
2035   bar   = ''
2036   skip  = 'Already installed'
2037   mtx   = Mutex.new
2038   take1 = proc { mtx.synchronize { running && all.shift } }
2039   logh  = proc {
2040     cnt = bar.length
2041     $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})"
2042     $curbuf[2] = '[' + bar.ljust(tot) + ']'
2043     VIM::command('normal! 2G')
2044     VIM::command('redraw')
2045   }
2046   where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } }
2047   log   = proc { |name, result, type|
2048     mtx.synchronize do
2049       ing  = ![true, false].include?(type)
2050       bar += type ? '=' : 'x' unless ing
2051       b = case type
2052           when :install  then '+' when :update then '*'
2053           when true, nil then '-' else
2054             VIM::command("call add(s:update.errors, '#{name}')")
2055             'x'
2056           end
2057       result =
2058         if type || type.nil?
2059           ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"]
2060         elsif result =~ /^Interrupted|^Timeout/
2061           ["#{b} #{name}: #{result}"]
2062         else
2063           ["#{b} #{name}"] + result.lines.map { |l| "    " << l }
2064         end
2065       if lnum = where.call(name)
2066         $curbuf.delete lnum
2067         lnum = 4 if ing && lnum > maxy
2068       end
2069       result.each_with_index do |line, offset|
2070         $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp)
2071       end
2072       logh.call
2073     end
2074   }
2075   bt = proc { |cmd, name, type, cleanup|
2076     tried = timeout = 0
2077     begin
2078       tried += 1
2079       timeout += limit
2080       fd = nil
2081       data = ''
2082       if iswin
2083         Timeout::timeout(timeout) do
2084           tmp = VIM::evaluate('tempname()')
2085           system("(#{cmd}) > #{tmp}")
2086           data = File.read(tmp).chomp
2087           File.unlink tmp rescue nil
2088         end
2089       else
2090         fd = IO.popen(cmd).extend(PlugStream)
2091         first_line = true
2092         log_prob = 1.0 / nthr
2093         while line = Timeout::timeout(timeout) { fd.get_line }
2094           data << line
2095           log.call name, line.chomp, type if name && (first_line || rand < log_prob)
2096           first_line = false
2097         end
2098         fd.close
2099       end
2100       [$? == 0, data.chomp]
2101     rescue Timeout::Error, Interrupt => e
2102       if fd && !fd.closed?
2103         killall fd.pid
2104         fd.close
2105       end
2106       cleanup.call if cleanup
2107       if e.is_a?(Timeout::Error) && tried < tries
2108         3.downto(1) do |countdown|
2109           s = countdown > 1 ? 's' : ''
2110           log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type
2111           sleep 1
2112         end
2113         log.call name, 'Retrying ...', type
2114         retry
2115       end
2116       [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"]
2117     end
2118   }
2119   main = Thread.current
2120   threads = []
2121   watcher = Thread.new {
2122     if vim7
2123       while VIM::evaluate('getchar(1)')
2124         sleep 0.1
2125       end
2126     else
2127       require 'io/console' # >= Ruby 1.9
2128       nil until IO.console.getch == 3.chr
2129     end
2130     mtx.synchronize do
2131       running = false
2132       threads.each { |t| t.raise Interrupt } unless vim7
2133     end
2134     threads.each { |t| t.join rescue nil }
2135     main.kill
2136   }
2137   refresh = Thread.new {
2138     while true
2139       mtx.synchronize do
2140         break unless running
2141         VIM::command('noautocmd normal! a')
2142       end
2143       sleep 0.2
2144     end
2145   } if VIM::evaluate('s:mac_gui') == 1
2146
2147   clone_opt = VIM::evaluate('s:clone_opt').join(' ')
2148   progress = VIM::evaluate('s:progress_opt(1)')
2149   nthr.times do
2150     mtx.synchronize do
2151       threads << Thread.new {
2152         while pair = take1.call
2153           name = pair.first
2154           dir, uri, tag = pair.last.values_at *%w[dir uri tag]
2155           exists = File.directory? dir
2156           ok, result =
2157             if exists
2158               chdir = "#{cd} #{iswin ? dir : esc(dir)}"
2159               ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil
2160               current_uri = data.lines.to_a.last
2161               if !ret
2162                 if data =~ /^Interrupted|^Timeout/
2163                   [false, data]
2164                 else
2165                   [false, [data.chomp, "PlugClean required."].join($/)]
2166                 end
2167               elsif !compare_git_uri(current_uri, uri)
2168                 [false, ["Invalid URI: #{current_uri}",
2169                          "Expected:    #{uri}",
2170                          "PlugClean required."].join($/)]
2171               else
2172                 if pull
2173                   log.call name, 'Updating ...', :update
2174                   fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : ''
2175                   bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil
2176                 else
2177                   [true, skip]
2178                 end
2179               end
2180             else
2181               d = esc dir.sub(%r{[\\/]+$}, '')
2182               log.call name, 'Installing ...', :install
2183               bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc {
2184                 FileUtils.rm_rf dir
2185               }
2186             end
2187           mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok
2188           log.call name, result, ok
2189         end
2190       } if running
2191     end
2192   end
2193   threads.each { |t| t.join rescue nil }
2194   logh.call
2195   refresh.kill if refresh
2196   watcher.kill
2197 EOF
2198 endfunction
2199
2200 function! s:shellesc_cmd(arg, script)
2201   let escaped = substitute('"'.a:arg.'"', '[&|<>()@^!"]', '^&', 'g')
2202   return substitute(escaped, '%', (a:script ? '%' : '^') . '&', 'g')
2203 endfunction
2204
2205 function! s:shellesc_ps1(arg)
2206   return "'".substitute(escape(a:arg, '\"'), "'", "''", 'g')."'"
2207 endfunction
2208
2209 function! s:shellesc_sh(arg)
2210   return "'".substitute(a:arg, "'", "'\\\\''", 'g')."'"
2211 endfunction
2212
2213 " Escape the shell argument based on the shell.
2214 " Vim and Neovim's shellescape() are insufficient.
2215 " 1. shellslash determines whether to use single/double quotes.
2216 "    Double-quote escaping is fragile for cmd.exe.
2217 " 2. It does not work for powershell.
2218 " 3. It does not work for *sh shells if the command is executed
2219 "    via cmd.exe (ie. cmd.exe /c sh -c command command_args)
2220 " 4. It does not support batchfile syntax.
2221 "
2222 " Accepts an optional dictionary with the following keys:
2223 " - shell: same as Vim/Neovim 'shell' option.
2224 "          If unset, fallback to 'cmd.exe' on Windows or 'sh'.
2225 " - script: If truthy and shell is cmd.exe, escape for batchfile syntax.
2226 function! plug#shellescape(arg, ...)
2227   if a:arg =~# '^[A-Za-z0-9_/:.-]\+$'
2228     return a:arg
2229   endif
2230   let opts = a:0 > 0 && type(a:1) == s:TYPE.dict ? a:1 : {}
2231   let shell = get(opts, 'shell', s:is_win ? 'cmd.exe' : 'sh')
2232   let script = get(opts, 'script', 1)
2233   if shell =~# 'cmd\(\.exe\)\?$'
2234     return s:shellesc_cmd(a:arg, script)
2235   elseif s:is_powershell(shell)
2236     return s:shellesc_ps1(a:arg)
2237   endif
2238   return s:shellesc_sh(a:arg)
2239 endfunction
2240
2241 function! s:glob_dir(path)
2242   return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)')
2243 endfunction
2244
2245 function! s:progress_bar(line, bar, total)
2246   call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']')
2247 endfunction
2248
2249 function! s:compare_git_uri(a, b)
2250   " See `git help clone'
2251   " https:// [user@] github.com[:port] / junegunn/vim-plug [.git]
2252   "          [git@]  github.com[:port] : junegunn/vim-plug [.git]
2253   " file://                            / junegunn/vim-plug        [/]
2254   "                                    / junegunn/vim-plug        [/]
2255   let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$'
2256   let ma = matchlist(a:a, pat)
2257   let mb = matchlist(a:b, pat)
2258   return ma[1:2] ==# mb[1:2]
2259 endfunction
2260
2261 function! s:format_message(bullet, name, message)
2262   if a:bullet != 'x'
2263     return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))]
2264   else
2265     let lines = map(s:lines(a:message), '"    ".v:val')
2266     return extend([printf('x %s:', a:name)], lines)
2267   endif
2268 endfunction
2269
2270 function! s:with_cd(cmd, dir, ...)
2271   let script = a:0 > 0 ? a:1 : 1
2272   return printf('cd%s %s && %s', s:is_win ? ' /d' : '', plug#shellescape(a:dir, {'script': script}), a:cmd)
2273 endfunction
2274
2275 function! s:system(cmd, ...)
2276   let batchfile = ''
2277   try
2278     let [sh, shellcmdflag, shrd] = s:chsh(1)
2279     if type(a:cmd) == s:TYPE.list
2280       " Neovim's system() supports list argument to bypass the shell
2281       " but it cannot set the working directory for the command.
2282       " Assume that the command does not rely on the shell.
2283       if has('nvim') && a:0 == 0
2284         return system(a:cmd)
2285       endif
2286       let cmd = join(map(copy(a:cmd), 'plug#shellescape(v:val, {"shell": &shell, "script": 0})'))
2287       if s:is_powershell(&shell)
2288         let cmd = '& ' . cmd
2289       endif
2290     else
2291       let cmd = a:cmd
2292     endif
2293     if a:0 > 0
2294       let cmd = s:with_cd(cmd, a:1, type(a:cmd) != s:TYPE.list)
2295     endif
2296     if s:is_win && type(a:cmd) != s:TYPE.list
2297       let [batchfile, cmd] = s:batchfile(cmd)
2298     endif
2299     return system(cmd)
2300   finally
2301     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2302     if s:is_win && filereadable(batchfile)
2303       call delete(batchfile)
2304     endif
2305   endtry
2306 endfunction
2307
2308 function! s:system_chomp(...)
2309   let ret = call('s:system', a:000)
2310   return v:shell_error ? '' : substitute(ret, '\n$', '', '')
2311 endfunction
2312
2313 function! s:git_validate(spec, check_branch)
2314   let err = ''
2315   if isdirectory(a:spec.dir)
2316     let result = [s:git_local_branch(a:spec.dir), s:git_origin_url(a:spec.dir)]
2317     let remote = result[-1]
2318     if empty(remote)
2319       let err = join([remote, 'PlugClean required.'], "\n")
2320     elseif !s:compare_git_uri(remote, a:spec.uri)
2321       let err = join(['Invalid URI: '.remote,
2322                     \ 'Expected:    '.a:spec.uri,
2323                     \ 'PlugClean required.'], "\n")
2324     elseif a:check_branch && has_key(a:spec, 'commit')
2325       let sha = s:git_revision(a:spec.dir)
2326       if empty(sha)
2327         let err = join(add(result, 'PlugClean required.'), "\n")
2328       elseif !s:hash_match(sha, a:spec.commit)
2329         let err = join([printf('Invalid HEAD (expected: %s, actual: %s)',
2330                               \ a:spec.commit[:6], sha[:6]),
2331                       \ 'PlugUpdate required.'], "\n")
2332       endif
2333     elseif a:check_branch
2334       let current_branch = result[0]
2335       " Check tag
2336       let origin_branch = s:git_origin_branch(a:spec)
2337       if has_key(a:spec, 'tag')
2338         let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir)
2339         if a:spec.tag !=# tag && a:spec.tag !~ '\*'
2340           let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.',
2341                 \ (empty(tag) ? 'N/A' : tag), a:spec.tag)
2342         endif
2343       " Check branch
2344       elseif origin_branch !=# current_branch
2345         let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.',
2346               \ current_branch, origin_branch)
2347       endif
2348       if empty(err)
2349         let [ahead, behind] = split(s:lastline(s:system([
2350         \ 'git', 'rev-list', '--count', '--left-right',
2351         \ printf('HEAD...origin/%s', origin_branch)
2352         \ ], a:spec.dir)), '\t')
2353         if !v:shell_error && ahead
2354           if behind
2355             " Only mention PlugClean if diverged, otherwise it's likely to be
2356             " pushable (and probably not that messed up).
2357             let err = printf(
2358                   \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n"
2359                   \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', origin_branch, ahead, behind)
2360           else
2361             let err = printf("Ahead of origin/%s by %d commit(s).\n"
2362                   \ .'Cannot update until local changes are pushed.',
2363                   \ origin_branch, ahead)
2364           endif
2365         endif
2366       endif
2367     endif
2368   else
2369     let err = 'Not found'
2370   endif
2371   return [err, err =~# 'PlugClean']
2372 endfunction
2373
2374 function! s:rm_rf(dir)
2375   if isdirectory(a:dir)
2376     return s:system(s:is_win
2377     \ ? 'rmdir /S /Q '.plug#shellescape(a:dir)
2378     \ : ['rm', '-rf', a:dir])
2379   endif
2380 endfunction
2381
2382 function! s:clean(force)
2383   call s:prepare()
2384   call append(0, 'Searching for invalid plugins in '.g:plug_home)
2385   call append(1, '')
2386
2387   " List of valid directories
2388   let dirs = []
2389   let errs = {}
2390   let [cnt, total] = [0, len(g:plugs)]
2391   for [name, spec] in items(g:plugs)
2392     if !s:is_managed(name)
2393       call add(dirs, spec.dir)
2394     else
2395       let [err, clean] = s:git_validate(spec, 1)
2396       if clean
2397         let errs[spec.dir] = s:lines(err)[0]
2398       else
2399         call add(dirs, spec.dir)
2400       endif
2401     endif
2402     let cnt += 1
2403     call s:progress_bar(2, repeat('=', cnt), total)
2404     normal! 2G
2405     redraw
2406   endfor
2407
2408   let allowed = {}
2409   for dir in dirs
2410     let allowed[s:dirpath(s:plug_fnamemodify(dir, ':h:h'))] = 1
2411     let allowed[dir] = 1
2412     for child in s:glob_dir(dir)
2413       let allowed[child] = 1
2414     endfor
2415   endfor
2416
2417   let todo = []
2418   let found = sort(s:glob_dir(g:plug_home))
2419   while !empty(found)
2420     let f = remove(found, 0)
2421     if !has_key(allowed, f) && isdirectory(f)
2422       call add(todo, f)
2423       call append(line('$'), '- ' . f)
2424       if has_key(errs, f)
2425         call append(line('$'), '    ' . errs[f])
2426       endif
2427       let found = filter(found, 'stridx(v:val, f) != 0')
2428     end
2429   endwhile
2430
2431   4
2432   redraw
2433   if empty(todo)
2434     call append(line('$'), 'Already clean.')
2435   else
2436     let s:clean_count = 0
2437     call append(3, ['Directories to delete:', ''])
2438     redraw!
2439     if a:force || s:ask_no_interrupt('Delete all directories?')
2440       call s:delete([6, line('$')], 1)
2441     else
2442       call setline(4, 'Cancelled.')
2443       nnoremap <silent> <buffer> d :set opfunc=<sid>delete_op<cr>g@
2444       nmap     <silent> <buffer> dd d_
2445       xnoremap <silent> <buffer> d :<c-u>call <sid>delete_op(visualmode(), 1)<cr>
2446       echo 'Delete the lines (d{motion}) to delete the corresponding directories'
2447     endif
2448   endif
2449   4
2450   setlocal nomodifiable
2451 endfunction
2452
2453 function! s:delete_op(type, ...)
2454   call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0)
2455 endfunction
2456
2457 function! s:delete(range, force)
2458   let [l1, l2] = a:range
2459   let force = a:force
2460   let err_count = 0
2461   while l1 <= l2
2462     let line = getline(l1)
2463     if line =~ '^- ' && isdirectory(line[2:])
2464       execute l1
2465       redraw!
2466       let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1)
2467       let force = force || answer > 1
2468       if answer
2469         let err = s:rm_rf(line[2:])
2470         setlocal modifiable
2471         if empty(err)
2472           call setline(l1, '~'.line[1:])
2473           let s:clean_count += 1
2474         else
2475           delete _
2476           call append(l1 - 1, s:format_message('x', line[1:], err))
2477           let l2 += len(s:lines(err))
2478           let err_count += 1
2479         endif
2480         let msg = printf('Removed %d directories.', s:clean_count)
2481         if err_count > 0
2482           let msg .= printf(' Failed to remove %d directories.', err_count)
2483         endif
2484         call setline(4, msg)
2485         setlocal nomodifiable
2486       endif
2487     endif
2488     let l1 += 1
2489   endwhile
2490 endfunction
2491
2492 function! s:upgrade()
2493   echo 'Downloading the latest version of vim-plug'
2494   redraw
2495   let tmp = s:plug_tempname()
2496   let new = tmp . '/plug.vim'
2497
2498   try
2499     let out = s:system(['git', 'clone', '--depth', '1', s:plug_src, tmp])
2500     if v:shell_error
2501       return s:err('Error upgrading vim-plug: '. out)
2502     endif
2503
2504     if readfile(s:me) ==# readfile(new)
2505       echo 'vim-plug is already up-to-date'
2506       return 0
2507     else
2508       call rename(s:me, s:me . '.old')
2509       call rename(new, s:me)
2510       unlet g:loaded_plug
2511       echo 'vim-plug has been upgraded'
2512       return 1
2513     endif
2514   finally
2515     silent! call s:rm_rf(tmp)
2516   endtry
2517 endfunction
2518
2519 function! s:upgrade_specs()
2520   for spec in values(g:plugs)
2521     let spec.frozen = get(spec, 'frozen', 0)
2522   endfor
2523 endfunction
2524
2525 function! s:status()
2526   call s:prepare()
2527   call append(0, 'Checking plugins')
2528   call append(1, '')
2529
2530   let ecnt = 0
2531   let unloaded = 0
2532   let [cnt, total] = [0, len(g:plugs)]
2533   for [name, spec] in items(g:plugs)
2534     let is_dir = isdirectory(spec.dir)
2535     if has_key(spec, 'uri')
2536       if is_dir
2537         let [err, _] = s:git_validate(spec, 1)
2538         let [valid, msg] = [empty(err), empty(err) ? 'OK' : err]
2539       else
2540         let [valid, msg] = [0, 'Not found. Try PlugInstall.']
2541       endif
2542     else
2543       if is_dir
2544         let [valid, msg] = [1, 'OK']
2545       else
2546         let [valid, msg] = [0, 'Not found.']
2547       endif
2548     endif
2549     let cnt += 1
2550     let ecnt += !valid
2551     " `s:loaded` entry can be missing if PlugUpgraded
2552     if is_dir && get(s:loaded, name, -1) == 0
2553       let unloaded = 1
2554       let msg .= ' (not loaded)'
2555     endif
2556     call s:progress_bar(2, repeat('=', cnt), total)
2557     call append(3, s:format_message(valid ? '-' : 'x', name, msg))
2558     normal! 2G
2559     redraw
2560   endfor
2561   call setline(1, 'Finished. '.ecnt.' error(s).')
2562   normal! gg
2563   setlocal nomodifiable
2564   if unloaded
2565     echo "Press 'L' on each line to load plugin, or 'U' to update"
2566     nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2567     xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2568   end
2569 endfunction
2570
2571 function! s:extract_name(str, prefix, suffix)
2572   return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$')
2573 endfunction
2574
2575 function! s:status_load(lnum)
2576   let line = getline(a:lnum)
2577   let name = s:extract_name(line, '-', '(not loaded)')
2578   if !empty(name)
2579     call plug#load(name)
2580     setlocal modifiable
2581     call setline(a:lnum, substitute(line, ' (not loaded)$', '', ''))
2582     setlocal nomodifiable
2583   endif
2584 endfunction
2585
2586 function! s:status_update() range
2587   let lines = getline(a:firstline, a:lastline)
2588   let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)')
2589   if !empty(names)
2590     echo
2591     execute 'PlugUpdate' join(names)
2592   endif
2593 endfunction
2594
2595 function! s:is_preview_window_open()
2596   silent! wincmd P
2597   if &previewwindow
2598     wincmd p
2599     return 1
2600   endif
2601 endfunction
2602
2603 function! s:find_name(lnum)
2604   for lnum in reverse(range(1, a:lnum))
2605     let line = getline(lnum)
2606     if empty(line)
2607       return ''
2608     endif
2609     let name = s:extract_name(line, '-', '')
2610     if !empty(name)
2611       return name
2612     endif
2613   endfor
2614   return ''
2615 endfunction
2616
2617 function! s:preview_commit()
2618   if b:plug_preview < 0
2619     let b:plug_preview = !s:is_preview_window_open()
2620   endif
2621
2622   let sha = matchstr(getline('.'), '^  \X*\zs[0-9a-f]\{7,9}')
2623   if empty(sha)
2624     let name = matchstr(getline('.'), '^- \zs[^:]*\ze:$')
2625     if empty(name)
2626       return
2627     endif
2628     let title = 'HEAD@{1}..'
2629     let command = 'git diff --no-color HEAD@{1}'
2630   else
2631     let title = sha
2632     let command = 'git show --no-color --pretty=medium '.sha
2633     let name = s:find_name(line('.'))
2634   endif
2635
2636   if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir)
2637     return
2638   endif
2639
2640   if exists('g:plug_pwindow') && !s:is_preview_window_open()
2641     execute g:plug_pwindow
2642     execute 'e' title
2643   else
2644     execute 'pedit' title
2645     wincmd P
2646   endif
2647   setlocal previewwindow filetype=git buftype=nofile bufhidden=wipe nobuflisted modifiable
2648   let batchfile = ''
2649   try
2650     let [sh, shellcmdflag, shrd] = s:chsh(1)
2651     let cmd = 'cd '.plug#shellescape(g:plugs[name].dir).' && '.command
2652     if s:is_win
2653       let [batchfile, cmd] = s:batchfile(cmd)
2654     endif
2655     execute 'silent %!' cmd
2656   finally
2657     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2658     if s:is_win && filereadable(batchfile)
2659       call delete(batchfile)
2660     endif
2661   endtry
2662   setlocal nomodifiable
2663   nnoremap <silent> <buffer> q :q<cr>
2664   wincmd p
2665 endfunction
2666
2667 function! s:section(flags)
2668   call search('\(^[x-] \)\@<=[^:]\+:', a:flags)
2669 endfunction
2670
2671 function! s:format_git_log(line)
2672   let indent = '  '
2673   let tokens = split(a:line, nr2char(1))
2674   if len(tokens) != 5
2675     return indent.substitute(a:line, '\s*$', '', '')
2676   endif
2677   let [graph, sha, refs, subject, date] = tokens
2678   let tag = matchstr(refs, 'tag: [^,)]\+')
2679   let tag = empty(tag) ? ' ' : ' ('.tag.') '
2680   return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date)
2681 endfunction
2682
2683 function! s:append_ul(lnum, text)
2684   call append(a:lnum, ['', a:text, repeat('-', len(a:text))])
2685 endfunction
2686
2687 function! s:diff()
2688   call s:prepare()
2689   call append(0, ['Collecting changes ...', ''])
2690   let cnts = [0, 0]
2691   let bar = ''
2692   let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)')
2693   call s:progress_bar(2, bar, len(total))
2694   for origin in [1, 0]
2695     let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))'))))
2696     if empty(plugs)
2697       continue
2698     endif
2699     call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:')
2700     for [k, v] in plugs
2701       let branch = s:git_origin_branch(v)
2702       if len(branch)
2703         let range = origin ? '..origin/'.branch : 'HEAD@{1}..'
2704         let cmd = ['git', 'log', '--graph', '--color=never']
2705         if s:git_version_requirement(2, 10, 0)
2706           call add(cmd, '--no-show-signature')
2707         endif
2708         call extend(cmd, ['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range])
2709         if has_key(v, 'rtp')
2710           call extend(cmd, ['--', v.rtp])
2711         endif
2712         let diff = s:system_chomp(cmd, v.dir)
2713         if !empty(diff)
2714           let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : ''
2715           call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)')))
2716           let cnts[origin] += 1
2717         endif
2718       endif
2719       let bar .= '='
2720       call s:progress_bar(2, bar, len(total))
2721       normal! 2G
2722       redraw
2723     endfor
2724     if !cnts[origin]
2725       call append(5, ['', 'N/A'])
2726     endif
2727   endfor
2728   call setline(1, printf('%d plugin(s) updated.', cnts[0])
2729         \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : ''))
2730
2731   if cnts[0] || cnts[1]
2732     nnoremap <silent> <buffer> <plug>(plug-preview) :silent! call <SID>preview_commit()<cr>
2733     if empty(maparg("\<cr>", 'n'))
2734       nmap <buffer> <cr> <plug>(plug-preview)
2735     endif
2736     if empty(maparg('o', 'n'))
2737       nmap <buffer> o <plug>(plug-preview)
2738     endif
2739   endif
2740   if cnts[0]
2741     nnoremap <silent> <buffer> X :call <SID>revert()<cr>
2742     echo "Press 'X' on each block to revert the update"
2743   endif
2744   normal! gg
2745   setlocal nomodifiable
2746 endfunction
2747
2748 function! s:revert()
2749   if search('^Pending updates', 'bnW')
2750     return
2751   endif
2752
2753   let name = s:find_name(line('.'))
2754   if empty(name) || !has_key(g:plugs, name) ||
2755     \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y'
2756     return
2757   endif
2758
2759   call s:system('git reset --hard HEAD@{1} && git checkout '.plug#shellescape(g:plugs[name].branch).' --', g:plugs[name].dir)
2760   setlocal modifiable
2761   normal! "_dap
2762   setlocal nomodifiable
2763   echo 'Reverted'
2764 endfunction
2765
2766 function! s:snapshot(force, ...) abort
2767   call s:prepare()
2768   setf vim
2769   call append(0, ['" Generated by vim-plug',
2770                 \ '" '.strftime("%c"),
2771                 \ '" :source this file in vim to restore the snapshot',
2772                 \ '" or execute: vim -S snapshot.vim',
2773                 \ '', '', 'PlugUpdate!'])
2774   1
2775   let anchor = line('$') - 3
2776   let names = sort(keys(filter(copy(g:plugs),
2777         \'has_key(v:val, "uri") && isdirectory(v:val.dir)')))
2778   for name in reverse(names)
2779     let sha = has_key(g:plugs[name], 'commit') ? g:plugs[name].commit : s:git_revision(g:plugs[name].dir)
2780     if !empty(sha)
2781       call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha))
2782       redraw
2783     endif
2784   endfor
2785
2786   if a:0 > 0
2787     let fn = s:plug_expand(a:1)
2788     if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?'))
2789       return
2790     endif
2791     call writefile(getline(1, '$'), fn)
2792     echo 'Saved as '.a:1
2793     silent execute 'e' s:esc(fn)
2794     setf vim
2795   endif
2796 endfunction
2797
2798 function! s:split_rtp()
2799   return split(&rtp, '\\\@<!,')
2800 endfunction
2801
2802 let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, ''))
2803 let s:last_rtp  = s:escrtp(get(s:split_rtp(), -1, ''))
2804
2805 if exists('g:plugs')
2806   let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs))
2807   call s:upgrade_specs()
2808   call s:define_commands()
2809 endif
2810
2811 let &cpo = s:cpo_save
2812 unlet s:cpo_save