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