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