]> git.sthu.org Git - vimconf.git/blob - autoload/plug.vim
9c296ace453d674c32c318db640ad3057dd92c14
[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 :if b:plug_preview==1<bar>pc<bar>endif<bar>bd<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:assign_name()
961 " Assign buffer name
962 let prefix = '[Plugins]'
963 let name = prefix
964 let idx = 2
965 while bufexists(name)
966 let name = printf('%s (%s)', prefix, idx)
967 let idx = idx + 1
968 endwhile
969 silent! execute 'f' fnameescape(name)
970 endfunction
971
972 function! s:chsh(swap)
973 let prev = [&shell, &shellcmdflag, &shellredir]
974 if !s:is_win
975 set shell=sh
976 endif
977 if a:swap
978 if &shell =~# 'powershell\(\.exe\)\?$' || &shell =~# 'pwsh$'
979 let &shellredir = '2>&1 | Out-File -Encoding UTF8 %s'
980 elseif &shell =~# 'sh' || &shell =~# 'cmd\(\.exe\)\?$'
981 set shellredir=>%s\ 2>&1
982 endif
983 endif
984 return prev
985 endfunction
986
987 function! s:bang(cmd, ...)
988 let batchfile = ''
989 try
990 let [sh, shellcmdflag, shrd] = s:chsh(a:0)
991 " FIXME: Escaping is incomplete. We could use shellescape with eval,
992 " but it won't work on Windows.
993 let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd
994 if s:is_win
995 let [batchfile, cmd] = s:batchfile(cmd)
996 endif
997 let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%')
998 execute "normal! :execute g:_plug_bang\<cr>\<cr>"
999 finally
1000 unlet g:_plug_bang
1001 let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
1002 if s:is_win && filereadable(batchfile)
1003 call delete(batchfile)
1004 endif
1005 endtry
1006 return v:shell_error ? 'Exit status: ' . v:shell_error : ''
1007 endfunction
1008
1009 function! s:regress_bar()
1010 let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '')
1011 call s:progress_bar(2, bar, len(bar))
1012 endfunction
1013
1014 function! s:is_updated(dir)
1015 return !empty(s:system_chomp(['git', 'log', '--pretty=format:%h', 'HEAD...HEAD@{1}'], a:dir))
1016 endfunction
1017
1018 function! s:do(pull, force, todo)
1019 for [name, spec] in items(a:todo)
1020 if !isdirectory(spec.dir)
1021 continue
1022 endif
1023 let installed = has_key(s:update.new, name)
1024 let updated = installed ? 0 :
1025 \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir))
1026 if a:force || installed || updated
1027 execute 'cd' s:esc(spec.dir)
1028 call append(3, '- Post-update hook for '. name .' ... ')
1029 let error = ''
1030 let type = type(spec.do)
1031 if type == s:TYPE.string
1032 if spec.do[0] == ':'
1033 if !get(s:loaded, name, 0)
1034 let s:loaded[name] = 1
1035 call s:reorg_rtp()
1036 endif
1037 call s:load_plugin(spec)
1038 try
1039 execute spec.do[1:]
1040 catch
1041 let error = v:exception
1042 endtry
1043 if !s:plug_window_exists()
1044 cd -
1045 throw 'Warning: vim-plug was terminated by the post-update hook of '.name
1046 endif
1047 else
1048 let error = s:bang(spec.do)
1049 endif
1050 elseif type == s:TYPE.funcref
1051 try
1052 call s:load_plugin(spec)
1053 let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged')
1054 call spec.do({ 'name': name, 'status': status, 'force': a:force })
1055 catch
1056 let error = v:exception
1057 endtry
1058 else
1059 let error = 'Invalid hook type'
1060 endif
1061 call s:switch_in()
1062 call setline(4, empty(error) ? (getline(4) . 'OK')
1063 \ : ('x' . getline(4)[1:] . error))
1064 if !empty(error)
1065 call add(s:update.errors, name)
1066 call s:regress_bar()
1067 endif
1068 cd -
1069 endif
1070 endfor
1071 endfunction
1072
1073 function! s:hash_match(a, b)
1074 return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0
1075 endfunction
1076
1077 function! s:checkout(spec)
1078 let sha = a:spec.commit
1079 let output = s:git_revision(a:spec.dir)
1080 if !empty(output) && !s:hash_match(sha, s:lines(output)[0])
1081 let credential_helper = s:git_version_requirement(2) ? '-c credential.helper= ' : ''
1082 let output = s:system(
1083 \ 'git '.credential_helper.'fetch --depth 999999 && git checkout '.plug#shellescape(sha).' --', a:spec.dir)
1084 endif
1085 return output
1086 endfunction
1087
1088 function! s:finish(pull)
1089 let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen'))
1090 if new_frozen
1091 let s = new_frozen > 1 ? 's' : ''
1092 call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s))
1093 endif
1094 call append(3, '- Finishing ... ') | 4
1095 redraw
1096 call plug#helptags()
1097 call plug#end()
1098 call setline(4, getline(4) . 'Done!')
1099 redraw
1100 let msgs = []
1101 if !empty(s:update.errors)
1102 call add(msgs, "Press 'R' to retry.")
1103 endif
1104 if a:pull && len(s:update.new) < len(filter(getline(5, '$'),
1105 \ "v:val =~ '^- ' && v:val !~# 'Already up.to.date'"))
1106 call add(msgs, "Press 'D' to see the updated changes.")
1107 endif
1108 echo join(msgs, ' ')
1109 call s:finish_bindings()
1110 endfunction
1111
1112 function! s:retry()
1113 if empty(s:update.errors)
1114 return
1115 endif
1116 echo
1117 call s:update_impl(s:update.pull, s:update.force,
1118 \ extend(copy(s:update.errors), [s:update.threads]))
1119 endfunction
1120
1121 function! s:is_managed(name)
1122 return has_key(g:plugs[a:name], 'uri')
1123 endfunction
1124
1125 function! s:names(...)
1126 return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)'))
1127 endfunction
1128
1129 function! s:check_ruby()
1130 silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'")
1131 if !exists('g:plug_ruby')
1132 redraw!
1133 return s:warn('echom', 'Warning: Ruby interface is broken')
1134 endif
1135 let ruby_version = split(g:plug_ruby, '\.')
1136 unlet g:plug_ruby
1137 return s:version_requirement(ruby_version, [1, 8, 7])
1138 endfunction
1139
1140 function! s:update_impl(pull, force, args) abort
1141 let sync = index(a:args, '--sync') >= 0 || has('vim_starting')
1142 let args = filter(copy(a:args), 'v:val != "--sync"')
1143 let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?
1144 \ remove(args, -1) : get(g:, 'plug_threads', 16)
1145
1146 let managed = filter(copy(g:plugs), 's:is_managed(v:key)')
1147 let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :
1148 \ filter(managed, 'index(args, v:key) >= 0')
1149
1150 if empty(todo)
1151 return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install'))
1152 endif
1153
1154 if !s:is_win && s:git_version_requirement(2, 3)
1155 let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : ''
1156 let $GIT_TERMINAL_PROMPT = 0
1157 for plug in values(todo)
1158 let plug.uri = substitute(plug.uri,
1159 \ '^https://git::@github\.com', 'https://github.com', '')
1160 endfor
1161 endif
1162
1163 if !isdirectory(g:plug_home)
1164 try
1165 call mkdir(g:plug_home, 'p')
1166 catch
1167 return s:err(printf('Invalid plug directory: %s. '.
1168 \ 'Try to call plug#begin with a valid directory', g:plug_home))
1169 endtry
1170 endif
1171
1172 if has('nvim') && !exists('*jobwait') && threads > 1
1173 call s:warn('echom', '[vim-plug] Update Neovim for parallel installer')
1174 endif
1175
1176 let use_job = s:nvim || s:vim8
1177 let python = (has('python') || has('python3')) && !use_job
1178 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()
1179
1180 let s:update = {
1181 \ 'start': reltime(),
1182 \ 'all': todo,
1183 \ 'todo': copy(todo),
1184 \ 'errors': [],
1185 \ 'pull': a:pull,
1186 \ 'force': a:force,
1187 \ 'new': {},
1188 \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1,
1189 \ 'bar': '',
1190 \ 'fin': 0
1191 \ }
1192
1193 call s:prepare(1)
1194 call append(0, ['', ''])
1195 normal! 2G
1196 silent! redraw
1197
1198 let s:clone_opt = []
1199 if get(g:, 'plug_shallow', 1)
1200 call extend(s:clone_opt, ['--depth', '1'])
1201 if s:git_version_requirement(1, 7, 10)
1202 call add(s:clone_opt, '--no-single-branch')
1203 endif
1204 endif
1205
1206 if has('win32unix') || has('wsl')
1207 call extend(s:clone_opt, ['-c', 'core.eol=lf', '-c', 'core.autocrlf=input'])
1208 endif
1209
1210 let s:submodule_opt = s:git_version_requirement(2, 8) ? ' --jobs='.threads : ''
1211
1212 " Python version requirement (>= 2.7)
1213 if python && !has('python3') && !ruby && !use_job && s:update.threads > 1
1214 redir => pyv
1215 silent python import platform; print platform.python_version()
1216 redir END
1217 let python = s:version_requirement(
1218 \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6])
1219 endif
1220
1221 if (python || ruby) && s:update.threads > 1
1222 try
1223 let imd = &imd
1224 if s:mac_gui
1225 set noimd
1226 endif
1227 if ruby
1228 call s:update_ruby()
1229 else
1230 call s:update_python()
1231 endif
1232 catch
1233 let lines = getline(4, '$')
1234 let printed = {}
1235 silent! 4,$d _
1236 for line in lines
1237 let name = s:extract_name(line, '.', '')
1238 if empty(name) || !has_key(printed, name)
1239 call append('$', line)
1240 if !empty(name)
1241 let printed[name] = 1
1242 if line[0] == 'x' && index(s:update.errors, name) < 0
1243 call add(s:update.errors, name)
1244 end
1245 endif
1246 endif
1247 endfor
1248 finally
1249 let &imd = imd
1250 call s:update_finish()
1251 endtry
1252 else
1253 call s:update_vim()
1254 while use_job && sync
1255 sleep 100m
1256 if s:update.fin
1257 break
1258 endif
1259 endwhile
1260 endif
1261 endfunction
1262
1263 function! s:log4(name, msg)
1264 call setline(4, printf('- %s (%s)', a:msg, a:name))
1265 redraw
1266 endfunction
1267
1268 function! s:update_finish()
1269 if exists('s:git_terminal_prompt')
1270 let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt
1271 endif
1272 if s:switch_in()
1273 call append(3, '- Updating ...') | 4
1274 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))'))
1275 let [pos, _] = s:logpos(name)
1276 if !pos
1277 continue
1278 endif
1279 if has_key(spec, 'commit')
1280 call s:log4(name, 'Checking out '.spec.commit)
1281 let out = s:checkout(spec)
1282 elseif has_key(spec, 'tag')
1283 let tag = spec.tag
1284 if tag =~ '\*'
1285 let tags = s:lines(s:system('git tag --list '.plug#shellescape(tag).' --sort -version:refname 2>&1', spec.dir))
1286 if !v:shell_error && !empty(tags)
1287 let tag = tags[0]
1288 call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag))
1289 call append(3, '')
1290 endif
1291 endif
1292 call s:log4(name, 'Checking out '.tag)
1293 let out = s:system('git checkout -q '.plug#shellescape(tag).' -- 2>&1', spec.dir)
1294 else
1295 let branch = s:git_origin_branch(spec)
1296 call s:log4(name, 'Merging origin/'.s:esc(branch))
1297 let out = s:system('git checkout -q '.plug#shellescape(branch).' -- 2>&1'
1298 \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only '.plug#shellescape('origin/'.branch).' 2>&1')), spec.dir)
1299 endif
1300 if !v:shell_error && filereadable(spec.dir.'/.gitmodules') &&
1301 \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir))
1302 call s:log4(name, 'Updating submodules. This may take a while.')
1303 let out .= s:bang('git submodule update --init --recursive'.s:submodule_opt.' 2>&1', spec.dir)
1304 endif
1305 let msg = s:format_message(v:shell_error ? 'x': '-', name, out)
1306 if v:shell_error
1307 call add(s:update.errors, name)
1308 call s:regress_bar()
1309 silent execute pos 'd _'
1310 call append(4, msg) | 4
1311 elseif !empty(out)
1312 call setline(pos, msg[0])
1313 endif
1314 redraw
1315 endfor
1316 silent 4 d _
1317 try
1318 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")'))
1319 catch
1320 call s:warn('echom', v:exception)
1321 call s:warn('echo', '')
1322 return
1323 endtry
1324 call s:finish(s:update.pull)
1325 call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.')
1326 call s:switch_out('normal! gg')
1327 endif
1328 endfunction
1329
1330 function! s:job_abort()
1331 if (!s:nvim && !s:vim8) || !exists('s:jobs')
1332 return
1333 endif
1334
1335 for [name, j] in items(s:jobs)
1336 if s:nvim
1337 silent! call jobstop(j.jobid)
1338 elseif s:vim8
1339 silent! call job_stop(j.jobid)
1340 endif
1341 if j.new
1342 call s:rm_rf(g:plugs[name].dir)
1343 endif
1344 endfor
1345 let s:jobs = {}
1346 endfunction
1347
1348 function! s:last_non_empty_line(lines)
1349 let len = len(a:lines)
1350 for idx in range(len)
1351 let line = a:lines[len-idx-1]
1352 if !empty(line)
1353 return line
1354 endif
1355 endfor
1356 return ''
1357 endfunction
1358
1359 function! s:job_out_cb(self, data) abort
1360 let self = a:self
1361 let data = remove(self.lines, -1) . a:data
1362 let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]')
1363 call extend(self.lines, lines)
1364 " To reduce the number of buffer updates
1365 let self.tick = get(self, 'tick', -1) + 1
1366 if !self.running || self.tick % len(s:jobs) == 0
1367 let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-')
1368 let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines)
1369 call s:log(bullet, self.name, result)
1370 endif
1371 endfunction
1372
1373 function! s:job_exit_cb(self, data) abort
1374 let a:self.running = 0
1375 let a:self.error = a:data != 0
1376 call s:reap(a:self.name)
1377 call s:tick()
1378 endfunction
1379
1380 function! s:job_cb(fn, job, ch, data)
1381 if !s:plug_window_exists() " plug window closed
1382 return s:job_abort()
1383 endif
1384 call call(a:fn, [a:job, a:data])
1385 endfunction
1386
1387 function! s:nvim_cb(job_id, data, event) dict abort
1388 return (a:event == 'stdout' || a:event == 'stderr') ?
1389 \ s:job_cb('s:job_out_cb', self, 0, join(a:data, "\n")) :
1390 \ s:job_cb('s:job_exit_cb', self, 0, a:data)
1391 endfunction
1392
1393 function! s:spawn(name, cmd, opts)
1394 let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''],
1395 \ 'new': get(a:opts, 'new', 0) }
1396 let s:jobs[a:name] = job
1397
1398 if s:nvim
1399 if has_key(a:opts, 'dir')
1400 let job.cwd = a:opts.dir
1401 endif
1402 let argv = a:cmd
1403 call extend(job, {
1404 \ 'on_stdout': function('s:nvim_cb'),
1405 \ 'on_stderr': function('s:nvim_cb'),
1406 \ 'on_exit': function('s:nvim_cb'),
1407 \ })
1408 let jid = s:plug_call('jobstart', argv, job)
1409 if jid > 0
1410 let job.jobid = jid
1411 else
1412 let job.running = 0
1413 let job.error = 1
1414 let job.lines = [jid < 0 ? argv[0].' is not executable' :
1415 \ 'Invalid arguments (or job table is full)']
1416 endif
1417 elseif s:vim8
1418 let cmd = join(map(copy(a:cmd), 'plug#shellescape(v:val, {"script": 0})'))
1419 if has_key(a:opts, 'dir')
1420 let cmd = s:with_cd(cmd, a:opts.dir, 0)
1421 endif
1422 let argv = s:is_win ? ['cmd', '/s', '/c', '"'.cmd.'"'] : ['sh', '-c', cmd]
1423 let jid = job_start(s:is_win ? join(argv, ' ') : argv, {
1424 \ 'out_cb': function('s:job_cb', ['s:job_out_cb', job]),
1425 \ 'err_cb': function('s:job_cb', ['s:job_out_cb', job]),
1426 \ 'exit_cb': function('s:job_cb', ['s:job_exit_cb', job]),
1427 \ 'err_mode': 'raw',
1428 \ 'out_mode': 'raw'
1429 \})
1430 if job_status(jid) == 'run'
1431 let job.jobid = jid
1432 else
1433 let job.running = 0
1434 let job.error = 1
1435 let job.lines = ['Failed to start job']
1436 endif
1437 else
1438 let job.lines = s:lines(call('s:system', has_key(a:opts, 'dir') ? [a:cmd, a:opts.dir] : [a:cmd]))
1439 let job.error = v:shell_error != 0
1440 let job.running = 0
1441 endif
1442 endfunction
1443
1444 function! s:reap(name)
1445 let job = s:jobs[a:name]
1446 if job.error
1447 call add(s:update.errors, a:name)
1448 elseif get(job, 'new', 0)
1449 let s:update.new[a:name] = 1
1450 endif
1451 let s:update.bar .= job.error ? 'x' : '='
1452
1453 let bullet = job.error ? 'x' : '-'
1454 let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines)
1455 call s:log(bullet, a:name, empty(result) ? 'OK' : result)
1456 call s:bar()
1457
1458 call remove(s:jobs, a:name)
1459 endfunction
1460
1461 function! s:bar()
1462 if s:switch_in()
1463 let total = len(s:update.all)
1464 call setline(1, (s:update.pull ? 'Updating' : 'Installing').
1465 \ ' plugins ('.len(s:update.bar).'/'.total.')')
1466 call s:progress_bar(2, s:update.bar, total)
1467 call s:switch_out()
1468 endif
1469 endfunction
1470
1471 function! s:logpos(name)
1472 let max = line('$')
1473 for i in range(4, max > 4 ? max : 4)
1474 if getline(i) =~# '^[-+x*] '.a:name.':'
1475 for j in range(i + 1, max > 5 ? max : 5)
1476 if getline(j) !~ '^ '
1477 return [i, j - 1]
1478 endif
1479 endfor
1480 return [i, i]
1481 endif
1482 endfor
1483 return [0, 0]
1484 endfunction
1485
1486 function! s:log(bullet, name, lines)
1487 if s:switch_in()
1488 let [b, e] = s:logpos(a:name)
1489 if b > 0
1490 silent execute printf('%d,%d d _', b, e)
1491 if b > winheight('.')
1492 let b = 4
1493 endif
1494 else
1495 let b = 4
1496 endif
1497 " FIXME For some reason, nomodifiable is set after :d in vim8
1498 setlocal modifiable
1499 call append(b - 1, s:format_message(a:bullet, a:name, a:lines))
1500 call s:switch_out()
1501 endif
1502 endfunction
1503
1504 function! s:update_vim()
1505 let s:jobs = {}
1506
1507 call s:bar()
1508 call s:tick()
1509 endfunction
1510
1511 function! s:tick()
1512 let pull = s:update.pull
1513 let prog = s:progress_opt(s:nvim || s:vim8)
1514 while 1 " Without TCO, Vim stack is bound to explode
1515 if empty(s:update.todo)
1516 if empty(s:jobs) && !s:update.fin
1517 call s:update_finish()
1518 let s:update.fin = 1
1519 endif
1520 return
1521 endif
1522
1523 let name = keys(s:update.todo)[0]
1524 let spec = remove(s:update.todo, name)
1525 let new = empty(globpath(spec.dir, '.git', 1))
1526
1527 call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
1528 redraw
1529
1530 let has_tag = has_key(spec, 'tag')
1531 if !new
1532 let [error, _] = s:git_validate(spec, 0)
1533 if empty(error)
1534 if pull
1535 let cmd = s:git_version_requirement(2) ? ['git', '-c', 'credential.helper=', 'fetch'] : ['git', 'fetch']
1536 if has_tag && !empty(globpath(spec.dir, '.git/shallow'))
1537 call extend(cmd, ['--depth', '99999999'])
1538 endif
1539 if !empty(prog)
1540 call add(cmd, prog)
1541 endif
1542 call s:spawn(name, cmd, { 'dir': spec.dir })
1543 else
1544 let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 }
1545 endif
1546 else
1547 let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 }
1548 endif
1549 else
1550 let cmd = ['git', 'clone']
1551 if !has_tag
1552 call extend(cmd, s:clone_opt)
1553 endif
1554 if !empty(prog)
1555 call add(cmd, prog)
1556 endif
1557 call s:spawn(name, extend(cmd, [spec.uri, s:trim(spec.dir)]), { 'new': 1 })
1558 endif
1559
1560 if !s:jobs[name].running
1561 call s:reap(name)
1562 endif
1563 if len(s:jobs) >= s:update.threads
1564 break
1565 endif
1566 endwhile
1567 endfunction
1568
1569 function! s:update_python()
1570 let py_exe = has('python') ? 'python' : 'python3'
1571 execute py_exe "<< EOF"
1572 import datetime
1573 import functools
1574 import os
1575 try:
1576 import queue
1577 except ImportError:
1578 import Queue as queue
1579 import random
1580 import re
1581 import shutil
1582 import signal
1583 import subprocess
1584 import tempfile
1585 import threading as thr
1586 import time
1587 import traceback
1588 import vim
1589
1590 G_NVIM = vim.eval("has('nvim')") == '1'
1591 G_PULL = vim.eval('s:update.pull') == '1'
1592 G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1
1593 G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)'))
1594 G_CLONE_OPT = ' '.join(vim.eval('s:clone_opt'))
1595 G_PROGRESS = vim.eval('s:progress_opt(1)')
1596 G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads'))
1597 G_STOP = thr.Event()
1598 G_IS_WIN = vim.eval('s:is_win') == '1'
1599
1600 class PlugError(Exception):
1601 def __init__(self, msg):
1602 self.msg = msg
1603 class CmdTimedOut(PlugError):
1604 pass
1605 class CmdFailed(PlugError):
1606 pass
1607 class InvalidURI(PlugError):
1608 pass
1609 class Action(object):
1610 INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-']
1611
1612 class Buffer(object):
1613 def __init__(self, lock, num_plugs, is_pull):
1614 self.bar = ''
1615 self.event = 'Updating' if is_pull else 'Installing'
1616 self.lock = lock
1617 self.maxy = int(vim.eval('winheight(".")'))
1618 self.num_plugs = num_plugs
1619
1620 def __where(self, name):
1621 """ Find first line with name in current buffer. Return line num. """
1622 found, lnum = False, 0
1623 matcher = re.compile('^[-+x*] {0}:'.format(name))
1624 for line in vim.current.buffer:
1625 if matcher.search(line) is not None:
1626 found = True
1627 break
1628 lnum += 1
1629
1630 if not found:
1631 lnum = -1
1632 return lnum
1633
1634 def header(self):
1635 curbuf = vim.current.buffer
1636 curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs)
1637
1638 num_spaces = self.num_plugs - len(self.bar)
1639 curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ')
1640
1641 with self.lock:
1642 vim.command('normal! 2G')
1643 vim.command('redraw')
1644
1645 def write(self, action, name, lines):
1646 first, rest = lines[0], lines[1:]
1647 msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)]
1648 msg.extend([' ' + line for line in rest])
1649
1650 try:
1651 if action == Action.ERROR:
1652 self.bar += 'x'
1653 vim.command("call add(s:update.errors, '{0}')".format(name))
1654 elif action == Action.DONE:
1655 self.bar += '='
1656
1657 curbuf = vim.current.buffer
1658 lnum = self.__where(name)
1659 if lnum != -1: # Found matching line num
1660 del curbuf[lnum]
1661 if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]):
1662 lnum = 3
1663 else:
1664 lnum = 3
1665 curbuf.append(msg, lnum)
1666
1667 self.header()
1668 except vim.error:
1669 pass
1670
1671 class Command(object):
1672 CD = 'cd /d' if G_IS_WIN else 'cd'
1673
1674 def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None):
1675 self.cmd = cmd
1676 if cmd_dir:
1677 self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd)
1678 self.timeout = timeout
1679 self.callback = cb if cb else (lambda msg: None)
1680 self.clean = clean if clean else (lambda: None)
1681 self.proc = None
1682
1683 @property
1684 def alive(self):
1685 """ Returns true only if command still running. """
1686 return self.proc and self.proc.poll() is None
1687
1688 def execute(self, ntries=3):
1689 """ Execute the command with ntries if CmdTimedOut.
1690 Returns the output of the command if no Exception.
1691 """
1692 attempt, finished, limit = 0, False, self.timeout
1693
1694 while not finished:
1695 try:
1696 attempt += 1
1697 result = self.try_command()
1698 finished = True
1699 return result
1700 except CmdTimedOut:
1701 if attempt != ntries:
1702 self.notify_retry()
1703 self.timeout += limit
1704 else:
1705 raise
1706
1707 def notify_retry(self):
1708 """ Retry required for command, notify user. """
1709 for count in range(3, 0, -1):
1710 if G_STOP.is_set():
1711 raise KeyboardInterrupt
1712 msg = 'Timeout. Will retry in {0} second{1} ...'.format(
1713 count, 's' if count != 1 else '')
1714 self.callback([msg])
1715 time.sleep(1)
1716 self.callback(['Retrying ...'])
1717
1718 def try_command(self):
1719 """ Execute a cmd & poll for callback. Returns list of output.
1720 Raises CmdFailed -> return code for Popen isn't 0
1721 Raises CmdTimedOut -> command exceeded timeout without new output
1722 """
1723 first_line = True
1724
1725 try:
1726 tfile = tempfile.NamedTemporaryFile(mode='w+b')
1727 preexec_fn = not G_IS_WIN and os.setsid or None
1728 self.proc = subprocess.Popen(self.cmd, stdout=tfile,
1729 stderr=subprocess.STDOUT,
1730 stdin=subprocess.PIPE, shell=True,
1731 preexec_fn=preexec_fn)
1732 thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,))
1733 thrd.start()
1734
1735 thread_not_started = True
1736 while thread_not_started:
1737 try:
1738 thrd.join(0.1)
1739 thread_not_started = False
1740 except RuntimeError:
1741 pass
1742
1743 while self.alive:
1744 if G_STOP.is_set():
1745 raise KeyboardInterrupt
1746
1747 if first_line or random.random() < G_LOG_PROB:
1748 first_line = False
1749 line = '' if G_IS_WIN else nonblock_read(tfile.name)
1750 if line:
1751 self.callback([line])
1752
1753 time_diff = time.time() - os.path.getmtime(tfile.name)
1754 if time_diff > self.timeout:
1755 raise CmdTimedOut(['Timeout!'])
1756
1757 thrd.join(0.5)
1758
1759 tfile.seek(0)
1760 result = [line.decode('utf-8', 'replace').rstrip() for line in tfile]
1761
1762 if self.proc.returncode != 0:
1763 raise CmdFailed([''] + result)
1764
1765 return result
1766 except:
1767 self.terminate()
1768 raise
1769
1770 def terminate(self):
1771 """ Terminate process and cleanup. """
1772 if self.alive:
1773 if G_IS_WIN:
1774 os.kill(self.proc.pid, signal.SIGINT)
1775 else:
1776 os.killpg(self.proc.pid, signal.SIGTERM)
1777 self.clean()
1778
1779 class Plugin(object):
1780 def __init__(self, name, args, buf_q, lock):
1781 self.name = name
1782 self.args = args
1783 self.buf_q = buf_q
1784 self.lock = lock
1785 self.tag = args.get('tag', 0)
1786
1787 def manage(self):
1788 try:
1789 if os.path.exists(self.args['dir']):
1790 self.update()
1791 else:
1792 self.install()
1793 with self.lock:
1794 thread_vim_command("let s:update.new['{0}'] = 1".format(self.name))
1795 except PlugError as exc:
1796 self.write(Action.ERROR, self.name, exc.msg)
1797 except KeyboardInterrupt:
1798 G_STOP.set()
1799 self.write(Action.ERROR, self.name, ['Interrupted!'])
1800 except:
1801 # Any exception except those above print stack trace
1802 msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip())
1803 self.write(Action.ERROR, self.name, msg.split('\n'))
1804 raise
1805
1806 def install(self):
1807 target = self.args['dir']
1808 if target[-1] == '\\':
1809 target = target[0:-1]
1810
1811 def clean(target):
1812 def _clean():
1813 try:
1814 shutil.rmtree(target)
1815 except OSError:
1816 pass
1817 return _clean
1818
1819 self.write(Action.INSTALL, self.name, ['Installing ...'])
1820 callback = functools.partial(self.write, Action.INSTALL, self.name)
1821 cmd = 'git clone {0} {1} {2} {3} 2>&1'.format(
1822 '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'],
1823 esc(target))
1824 com = Command(cmd, None, G_TIMEOUT, callback, clean(target))
1825 result = com.execute(G_RETRIES)
1826 self.write(Action.DONE, self.name, result[-1:])
1827
1828 def repo_uri(self):
1829 cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url'
1830 command = Command(cmd, self.args['dir'], G_TIMEOUT,)
1831 result = command.execute(G_RETRIES)
1832 return result[-1]
1833
1834 def update(self):
1835 actual_uri = self.repo_uri()
1836 expect_uri = self.args['uri']
1837 regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$')
1838 ma = regex.match(actual_uri)
1839 mb = regex.match(expect_uri)
1840 if ma is None or mb is None or ma.groups() != mb.groups():
1841 msg = ['',
1842 'Invalid URI: {0}'.format(actual_uri),
1843 'Expected {0}'.format(expect_uri),
1844 'PlugClean required.']
1845 raise InvalidURI(msg)
1846
1847 if G_PULL:
1848 self.write(Action.UPDATE, self.name, ['Updating ...'])
1849 callback = functools.partial(self.write, Action.UPDATE, self.name)
1850 fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else ''
1851 cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS)
1852 com = Command(cmd, self.args['dir'], G_TIMEOUT, callback)
1853 result = com.execute(G_RETRIES)
1854 self.write(Action.DONE, self.name, result[-1:])
1855 else:
1856 self.write(Action.DONE, self.name, ['Already installed'])
1857
1858 def write(self, action, name, msg):
1859 self.buf_q.put((action, name, msg))
1860
1861 class PlugThread(thr.Thread):
1862 def __init__(self, tname, args):
1863 super(PlugThread, self).__init__()
1864 self.tname = tname
1865 self.args = args
1866
1867 def run(self):
1868 thr.current_thread().name = self.tname
1869 buf_q, work_q, lock = self.args
1870
1871 try:
1872 while not G_STOP.is_set():
1873 name, args = work_q.get_nowait()
1874 plug = Plugin(name, args, buf_q, lock)
1875 plug.manage()
1876 work_q.task_done()
1877 except queue.Empty:
1878 pass
1879
1880 class RefreshThread(thr.Thread):
1881 def __init__(self, lock):
1882 super(RefreshThread, self).__init__()
1883 self.lock = lock
1884 self.running = True
1885
1886 def run(self):
1887 while self.running:
1888 with self.lock:
1889 thread_vim_command('noautocmd normal! a')
1890 time.sleep(0.33)
1891
1892 def stop(self):
1893 self.running = False
1894
1895 if G_NVIM:
1896 def thread_vim_command(cmd):
1897 vim.session.threadsafe_call(lambda: vim.command(cmd))
1898 else:
1899 def thread_vim_command(cmd):
1900 vim.command(cmd)
1901
1902 def esc(name):
1903 return '"' + name.replace('"', '\"') + '"'
1904
1905 def nonblock_read(fname):
1906 """ Read a file with nonblock flag. Return the last line. """
1907 fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK)
1908 buf = os.read(fread, 100000).decode('utf-8', 'replace')
1909 os.close(fread)
1910
1911 line = buf.rstrip('\r\n')
1912 left = max(line.rfind('\r'), line.rfind('\n'))
1913 if left != -1:
1914 left += 1
1915 line = line[left:]
1916
1917 return line
1918
1919 def main():
1920 thr.current_thread().name = 'main'
1921 nthreads = int(vim.eval('s:update.threads'))
1922 plugs = vim.eval('s:update.todo')
1923 mac_gui = vim.eval('s:mac_gui') == '1'
1924
1925 lock = thr.Lock()
1926 buf = Buffer(lock, len(plugs), G_PULL)
1927 buf_q, work_q = queue.Queue(), queue.Queue()
1928 for work in plugs.items():
1929 work_q.put(work)
1930
1931 start_cnt = thr.active_count()
1932 for num in range(nthreads):
1933 tname = 'PlugT-{0:02}'.format(num)
1934 thread = PlugThread(tname, (buf_q, work_q, lock))
1935 thread.start()
1936 if mac_gui:
1937 rthread = RefreshThread(lock)
1938 rthread.start()
1939
1940 while not buf_q.empty() or thr.active_count() != start_cnt:
1941 try:
1942 action, name, msg = buf_q.get(True, 0.25)
1943 buf.write(action, name, ['OK'] if not msg else msg)
1944 buf_q.task_done()
1945 except queue.Empty:
1946 pass
1947 except KeyboardInterrupt:
1948 G_STOP.set()
1949
1950 if mac_gui:
1951 rthread.stop()
1952 rthread.join()
1953
1954 main()
1955 EOF
1956 endfunction
1957
1958 function! s:update_ruby()
1959 ruby << EOF
1960 module PlugStream
1961 SEP = ["\r", "\n", nil]
1962 def get_line
1963 buffer = ''
1964 loop do
1965 char = readchar rescue return
1966 if SEP.include? char.chr
1967 buffer << $/
1968 break
1969 else
1970 buffer << char
1971 end
1972 end
1973 buffer
1974 end
1975 end unless defined?(PlugStream)
1976
1977 def esc arg
1978 %["#{arg.gsub('"', '\"')}"]
1979 end
1980
1981 def killall pid
1982 pids = [pid]
1983 if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM
1984 pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil }
1985 else
1986 unless `which pgrep 2> /dev/null`.empty?
1987 children = pids
1988 until children.empty?
1989 children = children.map { |pid|
1990 `pgrep -P #{pid}`.lines.map { |l| l.chomp }
1991 }.flatten
1992 pids += children
1993 end
1994 end
1995 pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil }
1996 end
1997 end
1998
1999 def compare_git_uri a, b
2000 regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$}
2001 regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1)
2002 end
2003
2004 require 'thread'
2005 require 'fileutils'
2006 require 'timeout'
2007 running = true
2008 iswin = VIM::evaluate('s:is_win').to_i == 1
2009 pull = VIM::evaluate('s:update.pull').to_i == 1
2010 base = VIM::evaluate('g:plug_home')
2011 all = VIM::evaluate('s:update.todo')
2012 limit = VIM::evaluate('get(g:, "plug_timeout", 60)')
2013 tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1
2014 nthr = VIM::evaluate('s:update.threads').to_i
2015 maxy = VIM::evaluate('winheight(".")').to_i
2016 vim7 = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/
2017 cd = iswin ? 'cd /d' : 'cd'
2018 tot = VIM::evaluate('len(s:update.todo)') || 0
2019 bar = ''
2020 skip = 'Already installed'
2021 mtx = Mutex.new
2022 take1 = proc { mtx.synchronize { running && all.shift } }
2023 logh = proc {
2024 cnt = bar.length
2025 $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})"
2026 $curbuf[2] = '[' + bar.ljust(tot) + ']'
2027 VIM::command('normal! 2G')
2028 VIM::command('redraw')
2029 }
2030 where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } }
2031 log = proc { |name, result, type|
2032 mtx.synchronize do
2033 ing = ![true, false].include?(type)
2034 bar += type ? '=' : 'x' unless ing
2035 b = case type
2036 when :install then '+' when :update then '*'
2037 when true, nil then '-' else
2038 VIM::command("call add(s:update.errors, '#{name}')")
2039 'x'
2040 end
2041 result =
2042 if type || type.nil?
2043 ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"]
2044 elsif result =~ /^Interrupted|^Timeout/
2045 ["#{b} #{name}: #{result}"]
2046 else
2047 ["#{b} #{name}"] + result.lines.map { |l| " " << l }
2048 end
2049 if lnum = where.call(name)
2050 $curbuf.delete lnum
2051 lnum = 4 if ing && lnum > maxy
2052 end
2053 result.each_with_index do |line, offset|
2054 $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp)
2055 end
2056 logh.call
2057 end
2058 }
2059 bt = proc { |cmd, name, type, cleanup|
2060 tried = timeout = 0
2061 begin
2062 tried += 1
2063 timeout += limit
2064 fd = nil
2065 data = ''
2066 if iswin
2067 Timeout::timeout(timeout) do
2068 tmp = VIM::evaluate('tempname()')
2069 system("(#{cmd}) > #{tmp}")
2070 data = File.read(tmp).chomp
2071 File.unlink tmp rescue nil
2072 end
2073 else
2074 fd = IO.popen(cmd).extend(PlugStream)
2075 first_line = true
2076 log_prob = 1.0 / nthr
2077 while line = Timeout::timeout(timeout) { fd.get_line }
2078 data << line
2079 log.call name, line.chomp, type if name && (first_line || rand < log_prob)
2080 first_line = false
2081 end
2082 fd.close
2083 end
2084 [$? == 0, data.chomp]
2085 rescue Timeout::Error, Interrupt => e
2086 if fd && !fd.closed?
2087 killall fd.pid
2088 fd.close
2089 end
2090 cleanup.call if cleanup
2091 if e.is_a?(Timeout::Error) && tried < tries
2092 3.downto(1) do |countdown|
2093 s = countdown > 1 ? 's' : ''
2094 log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type
2095 sleep 1
2096 end
2097 log.call name, 'Retrying ...', type
2098 retry
2099 end
2100 [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"]
2101 end
2102 }
2103 main = Thread.current
2104 threads = []
2105 watcher = Thread.new {
2106 if vim7
2107 while VIM::evaluate('getchar(1)')
2108 sleep 0.1
2109 end
2110 else
2111 require 'io/console' # >= Ruby 1.9
2112 nil until IO.console.getch == 3.chr
2113 end
2114 mtx.synchronize do
2115 running = false
2116 threads.each { |t| t.raise Interrupt } unless vim7
2117 end
2118 threads.each { |t| t.join rescue nil }
2119 main.kill
2120 }
2121 refresh = Thread.new {
2122 while true
2123 mtx.synchronize do
2124 break unless running
2125 VIM::command('noautocmd normal! a')
2126 end
2127 sleep 0.2
2128 end
2129 } if VIM::evaluate('s:mac_gui') == 1
2130
2131 clone_opt = VIM::evaluate('s:clone_opt').join(' ')
2132 progress = VIM::evaluate('s:progress_opt(1)')
2133 nthr.times do
2134 mtx.synchronize do
2135 threads << Thread.new {
2136 while pair = take1.call
2137 name = pair.first
2138 dir, uri, tag = pair.last.values_at *%w[dir uri tag]
2139 exists = File.directory? dir
2140 ok, result =
2141 if exists
2142 chdir = "#{cd} #{iswin ? dir : esc(dir)}"
2143 ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil
2144 current_uri = data.lines.to_a.last
2145 if !ret
2146 if data =~ /^Interrupted|^Timeout/
2147 [false, data]
2148 else
2149 [false, [data.chomp, "PlugClean required."].join($/)]
2150 end
2151 elsif !compare_git_uri(current_uri, uri)
2152 [false, ["Invalid URI: #{current_uri}",
2153 "Expected: #{uri}",
2154 "PlugClean required."].join($/)]
2155 else
2156 if pull
2157 log.call name, 'Updating ...', :update
2158 fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : ''
2159 bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil
2160 else
2161 [true, skip]
2162 end
2163 end
2164 else
2165 d = esc dir.sub(%r{[\\/]+$}, '')
2166 log.call name, 'Installing ...', :install
2167 bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc {
2168 FileUtils.rm_rf dir
2169 }
2170 end
2171 mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok
2172 log.call name, result, ok
2173 end
2174 } if running
2175 end
2176 end
2177 threads.each { |t| t.join rescue nil }
2178 logh.call
2179 refresh.kill if refresh
2180 watcher.kill
2181 EOF
2182 endfunction
2183
2184 function! s:shellesc_cmd(arg, script)
2185 let escaped = substitute('"'.a:arg.'"', '[&|<>()@^!"]', '^&', 'g')
2186 return substitute(escaped, '%', (a:script ? '%' : '^') . '&', 'g')
2187 endfunction
2188
2189 function! s:shellesc_ps1(arg)
2190 return "'".substitute(escape(a:arg, '\"'), "'", "''", 'g')."'"
2191 endfunction
2192
2193 function! s:shellesc_sh(arg)
2194 return "'".substitute(a:arg, "'", "'\\\\''", 'g')."'"
2195 endfunction
2196
2197 " Escape the shell argument based on the shell.
2198 " Vim and Neovim's shellescape() are insufficient.
2199 " 1. shellslash determines whether to use single/double quotes.
2200 " Double-quote escaping is fragile for cmd.exe.
2201 " 2. It does not work for powershell.
2202 " 3. It does not work for *sh shells if the command is executed
2203 " via cmd.exe (ie. cmd.exe /c sh -c command command_args)
2204 " 4. It does not support batchfile syntax.
2205 "
2206 " Accepts an optional dictionary with the following keys:
2207 " - shell: same as Vim/Neovim 'shell' option.
2208 " If unset, fallback to 'cmd.exe' on Windows or 'sh'.
2209 " - script: If truthy and shell is cmd.exe, escape for batchfile syntax.
2210 function! plug#shellescape(arg, ...)
2211 if a:arg =~# '^[A-Za-z0-9_/:.-]\+$'
2212 return a:arg
2213 endif
2214 let opts = a:0 > 0 && type(a:1) == s:TYPE.dict ? a:1 : {}
2215 let shell = get(opts, 'shell', s:is_win ? 'cmd.exe' : 'sh')
2216 let script = get(opts, 'script', 1)
2217 if shell =~# 'cmd\(\.exe\)\?$'
2218 return s:shellesc_cmd(a:arg, script)
2219 elseif shell =~# 'powershell\(\.exe\)\?$' || shell =~# 'pwsh$'
2220 return s:shellesc_ps1(a:arg)
2221 endif
2222 return s:shellesc_sh(a:arg)
2223 endfunction
2224
2225 function! s:glob_dir(path)
2226 return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)')
2227 endfunction
2228
2229 function! s:progress_bar(line, bar, total)
2230 call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']')
2231 endfunction
2232
2233 function! s:compare_git_uri(a, b)
2234 " See `git help clone'
2235 " https:// [user@] github.com[:port] / junegunn/vim-plug [.git]
2236 " [git@] github.com[:port] : junegunn/vim-plug [.git]
2237 " file:// / junegunn/vim-plug [/]
2238 " / junegunn/vim-plug [/]
2239 let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$'
2240 let ma = matchlist(a:a, pat)
2241 let mb = matchlist(a:b, pat)
2242 return ma[1:2] ==# mb[1:2]
2243 endfunction
2244
2245 function! s:format_message(bullet, name, message)
2246 if a:bullet != 'x'
2247 return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))]
2248 else
2249 let lines = map(s:lines(a:message), '" ".v:val')
2250 return extend([printf('x %s:', a:name)], lines)
2251 endif
2252 endfunction
2253
2254 function! s:with_cd(cmd, dir, ...)
2255 let script = a:0 > 0 ? a:1 : 1
2256 return printf('cd%s %s && %s', s:is_win ? ' /d' : '', plug#shellescape(a:dir, {'script': script}), a:cmd)
2257 endfunction
2258
2259 function! s:system(cmd, ...)
2260 let batchfile = ''
2261 try
2262 let [sh, shellcmdflag, shrd] = s:chsh(1)
2263 if type(a:cmd) == s:TYPE.list
2264 " Neovim's system() supports list argument to bypass the shell
2265 " but it cannot set the working directory for the command.
2266 " Assume that the command does not rely on the shell.
2267 if has('nvim') && a:0 == 0
2268 return system(a:cmd)
2269 endif
2270 let cmd = join(map(copy(a:cmd), 'plug#shellescape(v:val, {"shell": &shell, "script": 0})'))
2271 if &shell =~# 'powershell\(\.exe\)\?$'
2272 let cmd = '& ' . cmd
2273 endif
2274 else
2275 let cmd = a:cmd
2276 endif
2277 if a:0 > 0
2278 let cmd = s:with_cd(cmd, a:1, type(a:cmd) != s:TYPE.list)
2279 endif
2280 if s:is_win && type(a:cmd) != s:TYPE.list
2281 let [batchfile, cmd] = s:batchfile(cmd)
2282 endif
2283 return system(cmd)
2284 finally
2285 let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2286 if s:is_win && filereadable(batchfile)
2287 call delete(batchfile)
2288 endif
2289 endtry
2290 endfunction
2291
2292 function! s:system_chomp(...)
2293 let ret = call('s:system', a:000)
2294 return v:shell_error ? '' : substitute(ret, '\n$', '', '')
2295 endfunction
2296
2297 function! s:git_validate(spec, check_branch)
2298 let err = ''
2299 if isdirectory(a:spec.dir)
2300 let result = [s:git_local_branch(a:spec.dir), s:git_origin_url(a:spec.dir)]
2301 let remote = result[-1]
2302 if empty(remote)
2303 let err = join([remote, 'PlugClean required.'], "\n")
2304 elseif !s:compare_git_uri(remote, a:spec.uri)
2305 let err = join(['Invalid URI: '.remote,
2306 \ 'Expected: '.a:spec.uri,
2307 \ 'PlugClean required.'], "\n")
2308 elseif a:check_branch && has_key(a:spec, 'commit')
2309 let sha = s:git_revision(a:spec.dir)
2310 if empty(sha)
2311 let err = join(add(result, 'PlugClean required.'), "\n")
2312 elseif !s:hash_match(sha, a:spec.commit)
2313 let err = join([printf('Invalid HEAD (expected: %s, actual: %s)',
2314 \ a:spec.commit[:6], sha[:6]),
2315 \ 'PlugUpdate required.'], "\n")
2316 endif
2317 elseif a:check_branch
2318 let current_branch = result[0]
2319 " Check tag
2320 let origin_branch = s:git_origin_branch(a:spec)
2321 if has_key(a:spec, 'tag')
2322 let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir)
2323 if a:spec.tag !=# tag && a:spec.tag !~ '\*'
2324 let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.',
2325 \ (empty(tag) ? 'N/A' : tag), a:spec.tag)
2326 endif
2327 " Check branch
2328 elseif origin_branch !=# current_branch
2329 let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.',
2330 \ current_branch, origin_branch)
2331 endif
2332 if empty(err)
2333 let [ahead, behind] = split(s:lastline(s:system([
2334 \ 'git', 'rev-list', '--count', '--left-right',
2335 \ printf('HEAD...origin/%s', origin_branch)
2336 \ ], a:spec.dir)), '\t')
2337 if !v:shell_error && ahead
2338 if behind
2339 " Only mention PlugClean if diverged, otherwise it's likely to be
2340 " pushable (and probably not that messed up).
2341 let err = printf(
2342 \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n"
2343 \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', origin_branch, ahead, behind)
2344 else
2345 let err = printf("Ahead of origin/%s by %d commit(s).\n"
2346 \ .'Cannot update until local changes are pushed.',
2347 \ origin_branch, ahead)
2348 endif
2349 endif
2350 endif
2351 endif
2352 else
2353 let err = 'Not found'
2354 endif
2355 return [err, err =~# 'PlugClean']
2356 endfunction
2357
2358 function! s:rm_rf(dir)
2359 if isdirectory(a:dir)
2360 return s:system(s:is_win
2361 \ ? 'rmdir /S /Q '.plug#shellescape(a:dir)
2362 \ : ['rm', '-rf', a:dir])
2363 endif
2364 endfunction
2365
2366 function! s:clean(force)
2367 call s:prepare()
2368 call append(0, 'Searching for invalid plugins in '.g:plug_home)
2369 call append(1, '')
2370
2371 " List of valid directories
2372 let dirs = []
2373 let errs = {}
2374 let [cnt, total] = [0, len(g:plugs)]
2375 for [name, spec] in items(g:plugs)
2376 if !s:is_managed(name)
2377 call add(dirs, spec.dir)
2378 else
2379 let [err, clean] = s:git_validate(spec, 1)
2380 if clean
2381 let errs[spec.dir] = s:lines(err)[0]
2382 else
2383 call add(dirs, spec.dir)
2384 endif
2385 endif
2386 let cnt += 1
2387 call s:progress_bar(2, repeat('=', cnt), total)
2388 normal! 2G
2389 redraw
2390 endfor
2391
2392 let allowed = {}
2393 for dir in dirs
2394 let allowed[s:dirpath(s:plug_fnamemodify(dir, ':h:h'))] = 1
2395 let allowed[dir] = 1
2396 for child in s:glob_dir(dir)
2397 let allowed[child] = 1
2398 endfor
2399 endfor
2400
2401 let todo = []
2402 let found = sort(s:glob_dir(g:plug_home))
2403 while !empty(found)
2404 let f = remove(found, 0)
2405 if !has_key(allowed, f) && isdirectory(f)
2406 call add(todo, f)
2407 call append(line('$'), '- ' . f)
2408 if has_key(errs, f)
2409 call append(line('$'), ' ' . errs[f])
2410 endif
2411 let found = filter(found, 'stridx(v:val, f) != 0')
2412 end
2413 endwhile
2414
2415 4
2416 redraw
2417 if empty(todo)
2418 call append(line('$'), 'Already clean.')
2419 else
2420 let s:clean_count = 0
2421 call append(3, ['Directories to delete:', ''])
2422 redraw!
2423 if a:force || s:ask_no_interrupt('Delete all directories?')
2424 call s:delete([6, line('$')], 1)
2425 else
2426 call setline(4, 'Cancelled.')
2427 nnoremap <silent> <buffer> d :set opfunc=<sid>delete_op<cr>g@
2428 nmap <silent> <buffer> dd d_
2429 xnoremap <silent> <buffer> d :<c-u>call <sid>delete_op(visualmode(), 1)<cr>
2430 echo 'Delete the lines (d{motion}) to delete the corresponding directories'
2431 endif
2432 endif
2433 4
2434 setlocal nomodifiable
2435 endfunction
2436
2437 function! s:delete_op(type, ...)
2438 call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0)
2439 endfunction
2440
2441 function! s:delete(range, force)
2442 let [l1, l2] = a:range
2443 let force = a:force
2444 let err_count = 0
2445 while l1 <= l2
2446 let line = getline(l1)
2447 if line =~ '^- ' && isdirectory(line[2:])
2448 execute l1
2449 redraw!
2450 let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1)
2451 let force = force || answer > 1
2452 if answer
2453 let err = s:rm_rf(line[2:])
2454 setlocal modifiable
2455 if empty(err)
2456 call setline(l1, '~'.line[1:])
2457 let s:clean_count += 1
2458 else
2459 delete _
2460 call append(l1 - 1, s:format_message('x', line[1:], err))
2461 let l2 += len(s:lines(err))
2462 let err_count += 1
2463 endif
2464 let msg = printf('Removed %d directories.', s:clean_count)
2465 if err_count > 0
2466 let msg .= printf(' Failed to remove %d directories.', err_count)
2467 endif
2468 call setline(4, msg)
2469 setlocal nomodifiable
2470 endif
2471 endif
2472 let l1 += 1
2473 endwhile
2474 endfunction
2475
2476 function! s:upgrade()
2477 echo 'Downloading the latest version of vim-plug'
2478 redraw
2479 let tmp = s:plug_tempname()
2480 let new = tmp . '/plug.vim'
2481
2482 try
2483 let out = s:system(['git', 'clone', '--depth', '1', s:plug_src, tmp])
2484 if v:shell_error
2485 return s:err('Error upgrading vim-plug: '. out)
2486 endif
2487
2488 if readfile(s:me) ==# readfile(new)
2489 echo 'vim-plug is already up-to-date'
2490 return 0
2491 else
2492 call rename(s:me, s:me . '.old')
2493 call rename(new, s:me)
2494 unlet g:loaded_plug
2495 echo 'vim-plug has been upgraded'
2496 return 1
2497 endif
2498 finally
2499 silent! call s:rm_rf(tmp)
2500 endtry
2501 endfunction
2502
2503 function! s:upgrade_specs()
2504 for spec in values(g:plugs)
2505 let spec.frozen = get(spec, 'frozen', 0)
2506 endfor
2507 endfunction
2508
2509 function! s:status()
2510 call s:prepare()
2511 call append(0, 'Checking plugins')
2512 call append(1, '')
2513
2514 let ecnt = 0
2515 let unloaded = 0
2516 let [cnt, total] = [0, len(g:plugs)]
2517 for [name, spec] in items(g:plugs)
2518 let is_dir = isdirectory(spec.dir)
2519 if has_key(spec, 'uri')
2520 if is_dir
2521 let [err, _] = s:git_validate(spec, 1)
2522 let [valid, msg] = [empty(err), empty(err) ? 'OK' : err]
2523 else
2524 let [valid, msg] = [0, 'Not found. Try PlugInstall.']
2525 endif
2526 else
2527 if is_dir
2528 let [valid, msg] = [1, 'OK']
2529 else
2530 let [valid, msg] = [0, 'Not found.']
2531 endif
2532 endif
2533 let cnt += 1
2534 let ecnt += !valid
2535 " `s:loaded` entry can be missing if PlugUpgraded
2536 if is_dir && get(s:loaded, name, -1) == 0
2537 let unloaded = 1
2538 let msg .= ' (not loaded)'
2539 endif
2540 call s:progress_bar(2, repeat('=', cnt), total)
2541 call append(3, s:format_message(valid ? '-' : 'x', name, msg))
2542 normal! 2G
2543 redraw
2544 endfor
2545 call setline(1, 'Finished. '.ecnt.' error(s).')
2546 normal! gg
2547 setlocal nomodifiable
2548 if unloaded
2549 echo "Press 'L' on each line to load plugin, or 'U' to update"
2550 nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2551 xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2552 end
2553 endfunction
2554
2555 function! s:extract_name(str, prefix, suffix)
2556 return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$')
2557 endfunction
2558
2559 function! s:status_load(lnum)
2560 let line = getline(a:lnum)
2561 let name = s:extract_name(line, '-', '(not loaded)')
2562 if !empty(name)
2563 call plug#load(name)
2564 setlocal modifiable
2565 call setline(a:lnum, substitute(line, ' (not loaded)$', '', ''))
2566 setlocal nomodifiable
2567 endif
2568 endfunction
2569
2570 function! s:status_update() range
2571 let lines = getline(a:firstline, a:lastline)
2572 let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)')
2573 if !empty(names)
2574 echo
2575 execute 'PlugUpdate' join(names)
2576 endif
2577 endfunction
2578
2579 function! s:is_preview_window_open()
2580 silent! wincmd P
2581 if &previewwindow
2582 wincmd p
2583 return 1
2584 endif
2585 endfunction
2586
2587 function! s:find_name(lnum)
2588 for lnum in reverse(range(1, a:lnum))
2589 let line = getline(lnum)
2590 if empty(line)
2591 return ''
2592 endif
2593 let name = s:extract_name(line, '-', '')
2594 if !empty(name)
2595 return name
2596 endif
2597 endfor
2598 return ''
2599 endfunction
2600
2601 function! s:preview_commit()
2602 if b:plug_preview < 0
2603 let b:plug_preview = !s:is_preview_window_open()
2604 endif
2605
2606 let sha = matchstr(getline('.'), '^ \X*\zs[0-9a-f]\{7,9}')
2607 if empty(sha)
2608 return
2609 endif
2610
2611 let name = s:find_name(line('.'))
2612 if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir)
2613 return
2614 endif
2615
2616 if exists('g:plug_pwindow') && !s:is_preview_window_open()
2617 execute g:plug_pwindow
2618 execute 'e' sha
2619 else
2620 execute 'pedit' sha
2621 wincmd P
2622 endif
2623 setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable
2624 let batchfile = ''
2625 try
2626 let [sh, shellcmdflag, shrd] = s:chsh(1)
2627 let cmd = 'cd '.plug#shellescape(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha
2628 if s:is_win
2629 let [batchfile, cmd] = s:batchfile(cmd)
2630 endif
2631 execute 'silent %!' cmd
2632 finally
2633 let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2634 if s:is_win && filereadable(batchfile)
2635 call delete(batchfile)
2636 endif
2637 endtry
2638 setlocal nomodifiable
2639 nnoremap <silent> <buffer> q :q<cr>
2640 wincmd p
2641 endfunction
2642
2643 function! s:section(flags)
2644 call search('\(^[x-] \)\@<=[^:]\+:', a:flags)
2645 endfunction
2646
2647 function! s:format_git_log(line)
2648 let indent = ' '
2649 let tokens = split(a:line, nr2char(1))
2650 if len(tokens) != 5
2651 return indent.substitute(a:line, '\s*$', '', '')
2652 endif
2653 let [graph, sha, refs, subject, date] = tokens
2654 let tag = matchstr(refs, 'tag: [^,)]\+')
2655 let tag = empty(tag) ? ' ' : ' ('.tag.') '
2656 return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date)
2657 endfunction
2658
2659 function! s:append_ul(lnum, text)
2660 call append(a:lnum, ['', a:text, repeat('-', len(a:text))])
2661 endfunction
2662
2663 function! s:diff()
2664 call s:prepare()
2665 call append(0, ['Collecting changes ...', ''])
2666 let cnts = [0, 0]
2667 let bar = ''
2668 let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)')
2669 call s:progress_bar(2, bar, len(total))
2670 for origin in [1, 0]
2671 let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))'))))
2672 if empty(plugs)
2673 continue
2674 endif
2675 call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:')
2676 for [k, v] in plugs
2677 let branch = s:git_origin_branch(v)
2678 if len(branch)
2679 let range = origin ? '..origin/'.branch : 'HEAD@{1}..'
2680 let cmd = ['git', 'log', '--graph', '--color=never']
2681 if s:git_version_requirement(2, 10, 0)
2682 call add(cmd, '--no-show-signature')
2683 endif
2684 call extend(cmd, ['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range])
2685 if has_key(v, 'rtp')
2686 call extend(cmd, ['--', v.rtp])
2687 endif
2688 let diff = s:system_chomp(cmd, v.dir)
2689 if !empty(diff)
2690 let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : ''
2691 call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)')))
2692 let cnts[origin] += 1
2693 endif
2694 endif
2695 let bar .= '='
2696 call s:progress_bar(2, bar, len(total))
2697 normal! 2G
2698 redraw
2699 endfor
2700 if !cnts[origin]
2701 call append(5, ['', 'N/A'])
2702 endif
2703 endfor
2704 call setline(1, printf('%d plugin(s) updated.', cnts[0])
2705 \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : ''))
2706
2707 if cnts[0] || cnts[1]
2708 nnoremap <silent> <buffer> <plug>(plug-preview) :silent! call <SID>preview_commit()<cr>
2709 if empty(maparg("\<cr>", 'n'))
2710 nmap <buffer> <cr> <plug>(plug-preview)
2711 endif
2712 if empty(maparg('o', 'n'))
2713 nmap <buffer> o <plug>(plug-preview)
2714 endif
2715 endif
2716 if cnts[0]
2717 nnoremap <silent> <buffer> X :call <SID>revert()<cr>
2718 echo "Press 'X' on each block to revert the update"
2719 endif
2720 normal! gg
2721 setlocal nomodifiable
2722 endfunction
2723
2724 function! s:revert()
2725 if search('^Pending updates', 'bnW')
2726 return
2727 endif
2728
2729 let name = s:find_name(line('.'))
2730 if empty(name) || !has_key(g:plugs, name) ||
2731 \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y'
2732 return
2733 endif
2734
2735 call s:system('git reset --hard HEAD@{1} && git checkout '.plug#shellescape(g:plugs[name].branch).' --', g:plugs[name].dir)
2736 setlocal modifiable
2737 normal! "_dap
2738 setlocal nomodifiable
2739 echo 'Reverted'
2740 endfunction
2741
2742 function! s:snapshot(force, ...) abort
2743 call s:prepare()
2744 setf vim
2745 call append(0, ['" Generated by vim-plug',
2746 \ '" '.strftime("%c"),
2747 \ '" :source this file in vim to restore the snapshot',
2748 \ '" or execute: vim -S snapshot.vim',
2749 \ '', '', 'PlugUpdate!'])
2750 1
2751 let anchor = line('$') - 3
2752 let names = sort(keys(filter(copy(g:plugs),
2753 \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)')))
2754 for name in reverse(names)
2755 let sha = s:git_revision(g:plugs[name].dir)
2756 if !empty(sha)
2757 call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha))
2758 redraw
2759 endif
2760 endfor
2761
2762 if a:0 > 0
2763 let fn = s:plug_expand(a:1)
2764 if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?'))
2765 return
2766 endif
2767 call writefile(getline(1, '$'), fn)
2768 echo 'Saved as '.a:1
2769 silent execute 'e' s:esc(fn)
2770 setf vim
2771 endif
2772 endfunction
2773
2774 function! s:split_rtp()
2775 return split(&rtp, '\\\@<!,')
2776 endfunction
2777
2778 let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, ''))
2779 let s:last_rtp = s:escrtp(get(s:split_rtp(), -1, ''))
2780
2781 if exists('g:plugs')
2782 let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs))
2783 call s:upgrade_specs()
2784 call s:define_commands()
2785 endif
2786
2787 let &cpo = s:cpo_save
2788 unlet s:cpo_save