.config/nvim/autoload/plug.vim

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