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