ftp -o - https://jcs.org/move_in | sh -
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

vimrc: switch to vim-plug

I was having trouble getting a plugin to work with vundle and it
worked with this, so whatever.

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