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