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