diff options
Diffstat (limited to 'nvim')
-rw-r--r-- | nvim/.config/nvim/after/.netrwhist | 4 | ||||
-rw-r--r-- | nvim/.config/nvim/after/syntax/python.vim | 6 | ||||
-rw-r--r-- | nvim/.config/nvim/after/syntax/scheme.vim | 19 | ||||
-rw-r--r-- | nvim/.config/nvim/autoload/plug.vim.old | 2540 | ||||
-rw-r--r-- | nvim/.config/nvim/coc-settings.json | 54 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/asm.vim | 1 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/javascript.vim | 8 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/python.vim | 7 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/rust.vim | 1 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/scheme.vim | 10 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/tex.vim | 3 | ||||
-rw-r--r-- | nvim/.config/nvim/ftplugin/typescript.vim | 7 | ||||
-rw-r--r-- | nvim/.config/nvim/init.vim | 185 | ||||
-rw-r--r-- | nvim/.config/nvim/plugin/help.vim | 16 | ||||
-rw-r--r-- | nvim/.config/nvim/plugin/ignores.vim | 11 | ||||
-rw-r--r-- | nvim/.config/nvim/plugin/maps.vim | 78 | ||||
-rw-r--r-- | nvim/.config/nvim/plugin/statusline.vim | 136 | ||||
-rw-r--r-- | nvim/.config/nvim/plugin/textobjs.vim | 27 | ||||
-rw-r--r-- | nvim/.config/nvim/syntax/proto.vim | 106 |
19 files changed, 3219 insertions, 0 deletions
diff --git a/nvim/.config/nvim/after/.netrwhist b/nvim/.config/nvim/after/.netrwhist new file mode 100644 index 0000000..abf607f --- /dev/null +++ b/nvim/.config/nvim/after/.netrwhist | |||
@@ -0,0 +1,4 @@ | |||
1 | let g:netrw_dirhistmax =10 | ||
2 | let g:netrw_dirhistcnt =2 | ||
3 | let g:netrw_dirhist_2='/home/np/dotfiles/vim/.vim/plugin' | ||
4 | let g:netrw_dirhist_1='/home/np/code/rustuff/dijo/src' | ||
diff --git a/nvim/.config/nvim/after/syntax/python.vim b/nvim/.config/nvim/after/syntax/python.vim new file mode 100644 index 0000000..278cdc2 --- /dev/null +++ b/nvim/.config/nvim/after/syntax/python.vim | |||
@@ -0,0 +1,6 @@ | |||
1 | syntax keyword pyNiceLambda lambda conceal cchar=λ | ||
2 | highlight link pyNiceLambda secondAccent | ||
3 | |||
4 | highlight! link Conceal Noise | ||
5 | |||
6 | setlocal conceallevel=1 | ||
diff --git a/nvim/.config/nvim/after/syntax/scheme.vim b/nvim/.config/nvim/after/syntax/scheme.vim new file mode 100644 index 0000000..9a2972b --- /dev/null +++ b/nvim/.config/nvim/after/syntax/scheme.vim | |||
@@ -0,0 +1,19 @@ | |||
1 | syntax keyword scmNiceLambda lambda conceal cchar=λ | ||
2 | |||
3 | syntax clear schemeFunction | ||
4 | |||
5 | syntax match scmNiceOperator "<=" conceal cchar=≤ | ||
6 | syntax match scmNiceOperator ">=" conceal cchar=≥ | ||
7 | |||
8 | syn region scmNiceQuote matchgroup=secondAccent start=/'[`']*/ end=/[ \t\n()\[\]";]/me=e-1 | ||
9 | syn region scmNiceQuote matchgroup=secondAccent start=/'['`]*"/ skip=/\\[\\"]/ end=/"/ | ||
10 | syn region scmNiceQuote matchgroup=secondAccent start=/'['`]*|/ skip=/\\[\\|]/ end=/|/ | ||
11 | syn region scmNiceQuote matchgroup=secondAccent start=/'['`]*#\?(/ end=/)/ contains=ALLBUT,schemeQuasiquote,schemeQuasiquoteForm,schemeUnquote,schemeForm,schemeDatumCommentForm,schemeImport,@schemeImportCluster,@schemeSyntaxCluster | ||
12 | |||
13 | highlight link scmNiceLambda schemeSyntax | ||
14 | highlight link scmNiceOperator Noise | ||
15 | highlight link scmNiceQuote secondAccent | ||
16 | |||
17 | highlight! link Conceal Noise | ||
18 | |||
19 | setlocal conceallevel=1 | ||
diff --git a/nvim/.config/nvim/autoload/plug.vim.old b/nvim/.config/nvim/autoload/plug.vim.old new file mode 100644 index 0000000..2571fe3 --- /dev/null +++ b/nvim/.config/nvim/autoload/plug.vim.old | |||
@@ -0,0 +1,2540 @@ | |||
1 | " vim-plug: Vim plugin manager | ||
2 | " ============================ | ||
3 | " | ||
4 | " Download plug.vim and put it in ~/.vim/autoload | ||
5 | " | ||
6 | " curl -fLo ~/.vim/autoload/plug.vim --create-dirs \ | ||
7 | " https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim | ||
8 | " | ||
9 | " Edit your .vimrc | ||
10 | " | ||
11 | " call plug#begin('~/.vim/plugged') | ||
12 | " | ||
13 | " " Make sure you use single quotes | ||
14 | " | ||
15 | " " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align | ||
16 | " Plug 'junegunn/vim-easy-align' | ||
17 | " | ||
18 | " " Any valid git URL is allowed | ||
19 | " Plug 'https://github.com/junegunn/vim-github-dashboard.git' | ||
20 | " | ||
21 | " " Multiple Plug commands can be written in a single line using | separators | ||
22 | " Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets' | ||
23 | " | ||
24 | " " On-demand loading | ||
25 | " Plug 'scrooloose/nerdtree', { 'on': 'NERDTreeToggle' } | ||
26 | " Plug 'tpope/vim-fireplace', { 'for': 'clojure' } | ||
27 | " | ||
28 | " " Using a non-master branch | ||
29 | " Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' } | ||
30 | " | ||
31 | " " Using a tagged release; wildcard allowed (requires git 1.9.2 or above) | ||
32 | " Plug 'fatih/vim-go', { 'tag': '*' } | ||
33 | " | ||
34 | " " Plugin options | ||
35 | " Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' } | ||
36 | " | ||
37 | " " Plugin outside ~/.vim/plugged with post-update hook | ||
38 | " Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' } | ||
39 | " | ||
40 | " " Unmanaged plugin (manually installed and updated) | ||
41 | " Plug '~/my-prototype-plugin' | ||
42 | " | ||
43 | " " Initialize plugin system | ||
44 | " call plug#end() | ||
45 | " | ||
46 | " Then reload .vimrc and :PlugInstall to install plugins. | ||
47 | " | ||
48 | " Plug options: | ||
49 | " | ||
50 | "| Option | Description | | ||
51 | "| ----------------------- | ------------------------------------------------ | | ||
52 | "| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use | | ||
53 | "| `rtp` | Subdirectory that contains Vim plugin | | ||
54 | "| `dir` | Custom directory for the plugin | | ||
55 | "| `as` | Use different name for the plugin | | ||
56 | "| `do` | Post-update hook (string or funcref) | | ||
57 | "| `on` | On-demand loading: Commands or `<Plug>`-mappings | | ||
58 | "| `for` | On-demand loading: File types | | ||
59 | "| `frozen` | Do not update unless explicitly specified | | ||
60 | " | ||
61 | " More information: https://github.com/junegunn/vim-plug | ||
62 | " | ||
63 | " | ||
64 | " Copyright (c) 2017 Junegunn Choi | ||
65 | " | ||
66 | " MIT License | ||
67 | " | ||
68 | " Permission is hereby granted, free of charge, to any person obtaining | ||
69 | " a copy of this software and associated documentation files (the | ||
70 | " "Software"), to deal in the Software without restriction, including | ||
71 | " without limitation the rights to use, copy, modify, merge, publish, | ||
72 | " distribute, sublicense, and/or sell copies of the Software, and to | ||
73 | " permit persons to whom the Software is furnished to do so, subject to | ||
74 | " the following conditions: | ||
75 | " | ||
76 | " The above copyright notice and this permission notice shall be | ||
77 | " included in all copies or substantial portions of the Software. | ||
78 | " | ||
79 | " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
80 | " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
81 | " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
82 | " NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | ||
83 | " LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | ||
84 | " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | ||
85 | " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
86 | |||
87 | if exists('g:loaded_plug') | ||
88 | finish | ||
89 | endif | ||
90 | let g:loaded_plug = 1 | ||
91 | |||
92 | let s:cpo_save = &cpo | ||
93 | set cpo&vim | ||
94 | |||
95 | let s:plug_src = 'https://github.com/junegunn/vim-plug.git' | ||
96 | let s:plug_tab = get(s:, 'plug_tab', -1) | ||
97 | let s:plug_buf = get(s:, 'plug_buf', -1) | ||
98 | let s:mac_gui = has('gui_macvim') && has('gui_running') | ||
99 | let s:is_win = has('win32') | ||
100 | let s:nvim = has('nvim-0.2') || (has('nvim') && exists('*jobwait') && !s:is_win) | ||
101 | let s:vim8 = has('patch-8.0.0039') && exists('*job_start') | ||
102 | let s:me = resolve(expand('<sfile>:p')) | ||
103 | let s:base_spec = { 'branch': 'master', 'frozen': 0 } | ||
104 | let s:TYPE = { | ||
105 | \ 'string': type(''), | ||
106 | \ 'list': type([]), | ||
107 | \ 'dict': type({}), | ||
108 | \ 'funcref': type(function('call')) | ||
109 | \ } | ||
110 | let s:loaded = get(s:, 'loaded', {}) | ||
111 | let s:triggers = get(s:, 'triggers', {}) | ||
112 | |||
113 | function! plug#begin(...) | ||
114 | if a:0 > 0 | ||
115 | let s:plug_home_org = a:1 | ||
116 | let home = s:path(fnamemodify(expand(a:1), ':p')) | ||
117 | elseif exists('g:plug_home') | ||
118 | let home = s:path(g:plug_home) | ||
119 | elseif !empty(&rtp) | ||
120 | let home = s:path(split(&rtp, ',')[0]) . '/plugged' | ||
121 | else | ||
122 | return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.') | ||
123 | endif | ||
124 | if fnamemodify(home, ':t') ==# 'plugin' && fnamemodify(home, ':h') ==# s:first_rtp | ||
125 | return s:err('Invalid plug home. '.home.' is a standard Vim runtime path and is not allowed.') | ||
126 | endif | ||
127 | |||
128 | let g:plug_home = home | ||
129 | let g:plugs = {} | ||
130 | let g:plugs_order = [] | ||
131 | let s:triggers = {} | ||
132 | |||
133 | call s:define_commands() | ||
134 | return 1 | ||
135 | endfunction | ||
136 | |||
137 | function! s:define_commands() | ||
138 | command! -nargs=+ -bar Plug call plug#(<args>) | ||
139 | if !executable('git') | ||
140 | return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.') | ||
141 | endif | ||
142 | command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(<bang>0, [<f-args>]) | ||
143 | command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate call s:update(<bang>0, [<f-args>]) | ||
144 | command! -nargs=0 -bar -bang PlugClean call s:clean(<bang>0) | ||
145 | command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif | ||
146 | command! -nargs=0 -bar PlugStatus call s:status() | ||
147 | command! -nargs=0 -bar PlugDiff call s:diff() | ||
148 | command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(<bang>0, <f-args>) | ||
149 | endfunction | ||
150 | |||
151 | function! s:to_a(v) | ||
152 | return type(a:v) == s:TYPE.list ? a:v : [a:v] | ||
153 | endfunction | ||
154 | |||
155 | function! s:to_s(v) | ||
156 | return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n" | ||
157 | endfunction | ||
158 | |||
159 | function! s:glob(from, pattern) | ||
160 | return s:lines(globpath(a:from, a:pattern)) | ||
161 | endfunction | ||
162 | |||
163 | function! s:source(from, ...) | ||
164 | let found = 0 | ||
165 | for pattern in a:000 | ||
166 | for vim in s:glob(a:from, pattern) | ||
167 | execute 'source' s:esc(vim) | ||
168 | let found = 1 | ||
169 | endfor | ||
170 | endfor | ||
171 | return found | ||
172 | endfunction | ||
173 | |||
174 | function! s:assoc(dict, key, val) | ||
175 | let a:dict[a:key] = add(get(a:dict, a:key, []), a:val) | ||
176 | endfunction | ||
177 | |||
178 | function! s:ask(message, ...) | ||
179 | call inputsave() | ||
180 | echohl WarningMsg | ||
181 | let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) ')) | ||
182 | echohl None | ||
183 | call inputrestore() | ||
184 | echo "\r" | ||
185 | return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0 | ||
186 | endfunction | ||
187 | |||
188 | function! s:ask_no_interrupt(...) | ||
189 | try | ||
190 | return call('s:ask', a:000) | ||
191 | catch | ||
192 | return 0 | ||
193 | endtry | ||
194 | endfunction | ||
195 | |||
196 | function! s:lazy(plug, opt) | ||
197 | return has_key(a:plug, a:opt) && | ||
198 | \ (empty(s:to_a(a:plug[a:opt])) || | ||
199 | \ !isdirectory(a:plug.dir) || | ||
200 | \ len(s:glob(s:rtp(a:plug), 'plugin')) || | ||
201 | \ len(s:glob(s:rtp(a:plug), 'after/plugin'))) | ||
202 | endfunction | ||
203 | |||
204 | function! plug#end() | ||
205 | if !exists('g:plugs') | ||
206 | return s:err('Call plug#begin() first') | ||
207 | endif | ||
208 | |||
209 | if exists('#PlugLOD') | ||
210 | augroup PlugLOD | ||
211 | autocmd! | ||
212 | augroup END | ||
213 | augroup! PlugLOD | ||
214 | endif | ||
215 | let lod = { 'ft': {}, 'map': {}, 'cmd': {} } | ||
216 | |||
217 | if exists('g:did_load_filetypes') | ||
218 | filetype off | ||
219 | endif | ||
220 | for name in g:plugs_order | ||
221 | if !has_key(g:plugs, name) | ||
222 | continue | ||
223 | endif | ||
224 | let plug = g:plugs[name] | ||
225 | if get(s:loaded, name, 0) || !s:lazy(plug, 'on') && !s:lazy(plug, 'for') | ||
226 | let s:loaded[name] = 1 | ||
227 | continue | ||
228 | endif | ||
229 | |||
230 | if has_key(plug, 'on') | ||
231 | let s:triggers[name] = { 'map': [], 'cmd': [] } | ||
232 | for cmd in s:to_a(plug.on) | ||
233 | if cmd =~? '^<Plug>.\+' | ||
234 | if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i')) | ||
235 | call s:assoc(lod.map, cmd, name) | ||
236 | endif | ||
237 | call add(s:triggers[name].map, cmd) | ||
238 | elseif cmd =~# '^[A-Z]' | ||
239 | let cmd = substitute(cmd, '!*$', '', '') | ||
240 | if exists(':'.cmd) != 2 | ||
241 | call s:assoc(lod.cmd, cmd, name) | ||
242 | endif | ||
243 | call add(s:triggers[name].cmd, cmd) | ||
244 | else | ||
245 | call s:err('Invalid `on` option: '.cmd. | ||
246 | \ '. Should start with an uppercase letter or `<Plug>`.') | ||
247 | endif | ||
248 | endfor | ||
249 | endif | ||
250 | |||
251 | if has_key(plug, 'for') | ||
252 | let types = s:to_a(plug.for) | ||
253 | if !empty(types) | ||
254 | augroup filetypedetect | ||
255 | call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim') | ||
256 | augroup END | ||
257 | endif | ||
258 | for type in types | ||
259 | call s:assoc(lod.ft, type, name) | ||
260 | endfor | ||
261 | endif | ||
262 | endfor | ||
263 | |||
264 | for [cmd, names] in items(lod.cmd) | ||
265 | execute printf( | ||
266 | \ 'command! -nargs=* -range -bang -complete=file %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)', | ||
267 | \ cmd, string(cmd), string(names)) | ||
268 | endfor | ||
269 | |||
270 | for [map, names] in items(lod.map) | ||
271 | for [mode, map_prefix, key_prefix] in | ||
272 | \ [['i', '<C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']] | ||
273 | execute printf( | ||
274 | \ '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, %s, "%s")<CR>', | ||
275 | \ mode, map, map_prefix, string(map), string(names), mode != 'i', key_prefix) | ||
276 | endfor | ||
277 | endfor | ||
278 | |||
279 | for [ft, names] in items(lod.ft) | ||
280 | augroup PlugLOD | ||
281 | execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)', | ||
282 | \ ft, string(ft), string(names)) | ||
283 | augroup END | ||
284 | endfor | ||
285 | |||
286 | call s:reorg_rtp() | ||
287 | filetype plugin indent on | ||
288 | if has('vim_starting') | ||
289 | if has('syntax') && !exists('g:syntax_on') | ||
290 | syntax enable | ||
291 | end | ||
292 | else | ||
293 | call s:reload_plugins() | ||
294 | endif | ||
295 | endfunction | ||
296 | |||
297 | function! s:loaded_names() | ||
298 | return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)') | ||
299 | endfunction | ||
300 | |||
301 | function! s:load_plugin(spec) | ||
302 | call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim') | ||
303 | endfunction | ||
304 | |||
305 | function! s:reload_plugins() | ||
306 | for name in s:loaded_names() | ||
307 | call s:load_plugin(g:plugs[name]) | ||
308 | endfor | ||
309 | endfunction | ||
310 | |||
311 | function! s:trim(str) | ||
312 | return substitute(a:str, '[\/]\+$', '', '') | ||
313 | endfunction | ||
314 | |||
315 | function! s:version_requirement(val, min) | ||
316 | for idx in range(0, len(a:min) - 1) | ||
317 | let v = get(a:val, idx, 0) | ||
318 | if v < a:min[idx] | return 0 | ||
319 | elseif v > a:min[idx] | return 1 | ||
320 | endif | ||
321 | endfor | ||
322 | return 1 | ||
323 | endfunction | ||
324 | |||
325 | function! s:git_version_requirement(...) | ||
326 | if !exists('s:git_version') | ||
327 | let s:git_version = map(split(split(s:system('git --version'))[2], '\.'), 'str2nr(v:val)') | ||
328 | endif | ||
329 | return s:version_requirement(s:git_version, a:000) | ||
330 | endfunction | ||
331 | |||
332 | function! s:progress_opt(base) | ||
333 | return a:base && !s:is_win && | ||
334 | \ s:git_version_requirement(1, 7, 1) ? '--progress' : '' | ||
335 | endfunction | ||
336 | |||
337 | if s:is_win | ||
338 | function! s:rtp(spec) | ||
339 | return s:path(a:spec.dir . get(a:spec, 'rtp', '')) | ||
340 | endfunction | ||
341 | |||
342 | function! s:path(path) | ||
343 | return s:trim(substitute(a:path, '/', '\', 'g')) | ||
344 | endfunction | ||
345 | |||
346 | function! s:dirpath(path) | ||
347 | return s:path(a:path) . '\' | ||
348 | endfunction | ||
349 | |||
350 | function! s:is_local_plug(repo) | ||
351 | return a:repo =~? '^[a-z]:\|^[%~]' | ||
352 | endfunction | ||
353 | |||
354 | " Copied from fzf | ||
355 | function! s:wrap_cmds(cmds) | ||
356 | return map([ | ||
357 | \ '@echo off', | ||
358 | \ 'setlocal enabledelayedexpansion', | ||
359 | \ 'for /f "tokens=*" %%a in (''chcp'') do for %%b in (%%a) do set origchcp=%%b', | ||
360 | \ 'chcp 65001 > nul' | ||
361 | \ ] | ||
362 | \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds]) | ||
363 | \ + ['chcp !origchcp! > nul', 'endlocal'], | ||
364 | \ 'v:val."\r"') | ||
365 | endfunction | ||
366 | |||
367 | function! s:batchfile(cmd) | ||
368 | let batchfile = tempname().'.bat' | ||
369 | call writefile(s:wrap_cmds(a:cmd), batchfile) | ||
370 | let cmd = plug#shellescape(batchfile, {'shell': &shell, 'script': 1}) | ||
371 | if &shell =~# 'powershell\.exe$' | ||
372 | let cmd = '& ' . cmd | ||
373 | endif | ||
374 | return [batchfile, cmd] | ||
375 | endfunction | ||
376 | else | ||
377 | function! s:rtp(spec) | ||
378 | return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | ||
379 | endfunction | ||
380 | |||
381 | function! s:path(path) | ||
382 | return s:trim(a:path) | ||
383 | endfunction | ||
384 | |||
385 | function! s:dirpath(path) | ||
386 | return substitute(a:path, '[/\\]*$', '/', '') | ||
387 | endfunction | ||
388 | |||
389 | function! s:is_local_plug(repo) | ||
390 | return a:repo[0] =~ '[/$~]' | ||
391 | endfunction | ||
392 | endif | ||
393 | |||
394 | function! s:err(msg) | ||
395 | echohl ErrorMsg | ||
396 | echom '[vim-plug] '.a:msg | ||
397 | echohl None | ||
398 | endfunction | ||
399 | |||
400 | function! s:warn(cmd, msg) | ||
401 | echohl WarningMsg | ||
402 | execute a:cmd 'a:msg' | ||
403 | echohl None | ||
404 | endfunction | ||
405 | |||
406 | function! s:esc(path) | ||
407 | return escape(a:path, ' ') | ||
408 | endfunction | ||
409 | |||
410 | function! s:escrtp(path) | ||
411 | return escape(a:path, ' ,') | ||
412 | endfunction | ||
413 | |||
414 | function! s:remove_rtp() | ||
415 | for name in s:loaded_names() | ||
416 | let rtp = s:rtp(g:plugs[name]) | ||
417 | execute 'set rtp-='.s:escrtp(rtp) | ||
418 | let after = globpath(rtp, 'after') | ||
419 | if isdirectory(after) | ||
420 | execute 'set rtp-='.s:escrtp(after) | ||
421 | endif | ||
422 | endfor | ||
423 | endfunction | ||
424 | |||
425 | function! s:reorg_rtp() | ||
426 | if !empty(s:first_rtp) | ||
427 | execute 'set rtp-='.s:first_rtp | ||
428 | execute 'set rtp-='.s:last_rtp | ||
429 | endif | ||
430 | |||
431 | " &rtp is modified from outside | ||
432 | if exists('s:prtp') && s:prtp !=# &rtp | ||
433 | call s:remove_rtp() | ||
434 | unlet! s:middle | ||
435 | endif | ||
436 | |||
437 | let s:middle = get(s:, 'middle', &rtp) | ||
438 | let rtps = map(s:loaded_names(), 's:rtp(g:plugs[v:val])') | ||
439 | let afters = filter(map(copy(rtps), 'globpath(v:val, "after")'), '!empty(v:val)') | ||
440 | let rtp = join(map(rtps, 'escape(v:val, ",")'), ',') | ||
441 | \ . ','.s:middle.',' | ||
442 | \ . join(map(afters, 'escape(v:val, ",")'), ',') | ||
443 | let &rtp = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g') | ||
444 | let s:prtp = &rtp | ||
445 | |||
446 | if !empty(s:first_rtp) | ||
447 | execute 'set rtp^='.s:first_rtp | ||
448 | execute 'set rtp+='.s:last_rtp | ||
449 | endif | ||
450 | endfunction | ||
451 | |||
452 | function! s:doautocmd(...) | ||
453 | if exists('#'.join(a:000, '#')) | ||
454 | execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000) | ||
455 | endif | ||
456 | endfunction | ||
457 | |||
458 | function! s:dobufread(names) | ||
459 | for name in a:names | ||
460 | let path = s:rtp(g:plugs[name]) | ||
461 | for dir in ['ftdetect', 'ftplugin', 'after/ftdetect', 'after/ftplugin'] | ||
462 | if len(finddir(dir, path)) | ||
463 | if exists('#BufRead') | ||
464 | doautocmd BufRead | ||
465 | endif | ||
466 | return | ||
467 | endif | ||
468 | endfor | ||
469 | endfor | ||
470 | endfunction | ||
471 | |||
472 | function! plug#load(...) | ||
473 | if a:0 == 0 | ||
474 | return s:err('Argument missing: plugin name(s) required') | ||
475 | endif | ||
476 | if !exists('g:plugs') | ||
477 | return s:err('plug#begin was not called') | ||
478 | endif | ||
479 | let names = a:0 == 1 && type(a:1) == s:TYPE.list ? a:1 : a:000 | ||
480 | let unknowns = filter(copy(names), '!has_key(g:plugs, v:val)') | ||
481 | if !empty(unknowns) | ||
482 | let s = len(unknowns) > 1 ? 's' : '' | ||
483 | return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', '))) | ||
484 | end | ||
485 | let unloaded = filter(copy(names), '!get(s:loaded, v:val, 0)') | ||
486 | if !empty(unloaded) | ||
487 | for name in unloaded | ||
488 | call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) | ||
489 | endfor | ||
490 | call s:dobufread(unloaded) | ||
491 | return 1 | ||
492 | end | ||
493 | return 0 | ||
494 | endfunction | ||
495 | |||
496 | function! s:remove_triggers(name) | ||
497 | if !has_key(s:triggers, a:name) | ||
498 | return | ||
499 | endif | ||
500 | for cmd in s:triggers[a:name].cmd | ||
501 | execute 'silent! delc' cmd | ||
502 | endfor | ||
503 | for map in s:triggers[a:name].map | ||
504 | execute 'silent! unmap' map | ||
505 | execute 'silent! iunmap' map | ||
506 | endfor | ||
507 | call remove(s:triggers, a:name) | ||
508 | endfunction | ||
509 | |||
510 | function! s:lod(names, types, ...) | ||
511 | for name in a:names | ||
512 | call s:remove_triggers(name) | ||
513 | let s:loaded[name] = 1 | ||
514 | endfor | ||
515 | call s:reorg_rtp() | ||
516 | |||
517 | for name in a:names | ||
518 | let rtp = s:rtp(g:plugs[name]) | ||
519 | for dir in a:types | ||
520 | call s:source(rtp, dir.'/**/*.vim') | ||
521 | endfor | ||
522 | if a:0 | ||
523 | if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2)) | ||
524 | execute 'runtime' a:1 | ||
525 | endif | ||
526 | call s:source(rtp, a:2) | ||
527 | endif | ||
528 | call s:doautocmd('User', name) | ||
529 | endfor | ||
530 | endfunction | ||
531 | |||
532 | function! s:lod_ft(pat, names) | ||
533 | let syn = 'syntax/'.a:pat.'.vim' | ||
534 | call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn) | ||
535 | execute 'autocmd! PlugLOD FileType' a:pat | ||
536 | call s:doautocmd('filetypeplugin', 'FileType') | ||
537 | call s:doautocmd('filetypeindent', 'FileType') | ||
538 | endfunction | ||
539 | |||
540 | function! s:lod_cmd(cmd, bang, l1, l2, args, names) | ||
541 | call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) | ||
542 | call s:dobufread(a:names) | ||
543 | execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args) | ||
544 | endfunction | ||
545 | |||
546 | function! s:lod_map(map, names, with_prefix, prefix) | ||
547 | call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) | ||
548 | call s:dobufread(a:names) | ||
549 | let extra = '' | ||
550 | while 1 | ||
551 | let c = getchar(0) | ||
552 | if c == 0 | ||
553 | break | ||
554 | endif | ||
555 | let extra .= nr2char(c) | ||
556 | endwhile | ||
557 | |||
558 | if a:with_prefix | ||
559 | let prefix = v:count ? v:count : '' | ||
560 | let prefix .= '"'.v:register.a:prefix | ||
561 | if mode(1) == 'no' | ||
562 | if v:operator == 'c' | ||
563 | let prefix = "\<esc>" . prefix | ||
564 | endif | ||
565 | let prefix .= v:operator | ||
566 | endif | ||
567 | call feedkeys(prefix, 'n') | ||
568 | endif | ||
569 | call feedkeys(substitute(a:map, '^<Plug>', "\<Plug>", '') . extra) | ||
570 | endfunction | ||
571 | |||
572 | function! plug#(repo, ...) | ||
573 | if a:0 > 1 | ||
574 | return s:err('Invalid number of arguments (1..2)') | ||
575 | endif | ||
576 | |||
577 | try | ||
578 | let repo = s:trim(a:repo) | ||
579 | let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec | ||
580 | let name = get(opts, 'as', fnamemodify(repo, ':t:s?\.git$??')) | ||
581 | let spec = extend(s:infer_properties(name, repo), opts) | ||
582 | if !has_key(g:plugs, name) | ||
583 | call add(g:plugs_order, name) | ||
584 | endif | ||
585 | let g:plugs[name] = spec | ||
586 | let s:loaded[name] = get(s:loaded, name, 0) | ||
587 | catch | ||
588 | return s:err(v:exception) | ||
589 | endtry | ||
590 | endfunction | ||
591 | |||
592 | function! s:parse_options(arg) | ||
593 | let opts = copy(s:base_spec) | ||
594 | let type = type(a:arg) | ||
595 | if type == s:TYPE.string | ||
596 | let opts.tag = a:arg | ||
597 | elseif type == s:TYPE.dict | ||
598 | call extend(opts, a:arg) | ||
599 | if has_key(opts, 'dir') | ||
600 | let opts.dir = s:dirpath(expand(opts.dir)) | ||
601 | endif | ||
602 | else | ||
603 | throw 'Invalid argument type (expected: string or dictionary)' | ||
604 | endif | ||
605 | return opts | ||
606 | endfunction | ||
607 | |||
608 | function! s:infer_properties(name, repo) | ||
609 | let repo = a:repo | ||
610 | if s:is_local_plug(repo) | ||
611 | return { 'dir': s:dirpath(expand(repo)) } | ||
612 | else | ||
613 | if repo =~ ':' | ||
614 | let uri = repo | ||
615 | else | ||
616 | if repo !~ '/' | ||
617 | throw printf('Invalid argument: %s (implicit `vim-scripts'' expansion is deprecated)', repo) | ||
618 | endif | ||
619 | let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | ||
620 | let uri = printf(fmt, repo) | ||
621 | endif | ||
622 | return { 'dir': s:dirpath(g:plug_home.'/'.a:name), 'uri': uri } | ||
623 | endif | ||
624 | endfunction | ||
625 | |||
626 | function! s:install(force, names) | ||
627 | call s:update_impl(0, a:force, a:names) | ||
628 | endfunction | ||
629 | |||
630 | function! s:update(force, names) | ||
631 | call s:update_impl(1, a:force, a:names) | ||
632 | endfunction | ||
633 | |||
634 | function! plug#helptags() | ||
635 | if !exists('g:plugs') | ||
636 | return s:err('plug#begin was not called') | ||
637 | endif | ||
638 | for spec in values(g:plugs) | ||
639 | let docd = join([s:rtp(spec), 'doc'], '/') | ||
640 | if isdirectory(docd) | ||
641 | silent! execute 'helptags' s:esc(docd) | ||
642 | endif | ||
643 | endfor | ||
644 | return 1 | ||
645 | endfunction | ||
646 | |||
647 | function! s:syntax() | ||
648 | syntax clear | ||
649 | syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber | ||
650 | syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX | ||
651 | syn match plugNumber /[0-9]\+[0-9.]*/ contained | ||
652 | syn match plugBracket /[[\]]/ contained | ||
653 | syn match plugX /x/ contained | ||
654 | syn match plugDash /^-/ | ||
655 | syn match plugPlus /^+/ | ||
656 | syn match plugStar /^*/ | ||
657 | syn match plugMessage /\(^- \)\@<=.*/ | ||
658 | syn match plugName /\(^- \)\@<=[^ ]*:/ | ||
659 | syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/ | ||
660 | syn match plugTag /(tag: [^)]\+)/ | ||
661 | syn match plugInstall /\(^+ \)\@<=[^:]*/ | ||
662 | syn match plugUpdate /\(^* \)\@<=[^:]*/ | ||
663 | syn match plugCommit /^ \X*[0-9a-f]\{7,9} .*/ contains=plugRelDate,plugEdge,plugTag | ||
664 | syn match plugEdge /^ \X\+$/ | ||
665 | syn match plugEdge /^ \X*/ contained nextgroup=plugSha | ||
666 | syn match plugSha /[0-9a-f]\{7,9}/ contained | ||
667 | syn match plugRelDate /([^)]*)$/ contained | ||
668 | syn match plugNotLoaded /(not loaded)$/ | ||
669 | syn match plugError /^x.*/ | ||
670 | syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/ | ||
671 | syn match plugH2 /^.*:\n-\+$/ | ||
672 | syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean | ||
673 | hi def link plug1 Title | ||
674 | hi def link plug2 Repeat | ||
675 | hi def link plugH2 Type | ||
676 | hi def link plugX Exception | ||
677 | hi def link plugBracket Structure | ||
678 | hi def link plugNumber Number | ||
679 | |||
680 | hi def link plugDash Special | ||
681 | hi def link plugPlus Constant | ||
682 | hi def link plugStar Boolean | ||
683 | |||
684 | hi def link plugMessage Function | ||
685 | hi def link plugName Label | ||
686 | hi def link plugInstall Function | ||
687 | hi def link plugUpdate Type | ||
688 | |||
689 | hi def link plugError Error | ||
690 | hi def link plugDeleted Ignore | ||
691 | hi def link plugRelDate Comment | ||
692 | hi def link plugEdge PreProc | ||
693 | hi def link plugSha Identifier | ||
694 | hi def link plugTag Constant | ||
695 | |||
696 | hi def link plugNotLoaded Comment | ||
697 | endfunction | ||
698 | |||
699 | function! s:lpad(str, len) | ||
700 | return a:str . repeat(' ', a:len - len(a:str)) | ||
701 | endfunction | ||
702 | |||
703 | function! s:lines(msg) | ||
704 | return split(a:msg, "[\r\n]") | ||
705 | endfunction | ||
706 | |||
707 | function! s:lastline(msg) | ||
708 | return get(s:lines(a:msg), -1, '') | ||
709 | endfunction | ||
710 | |||
711 | function! s:new_window() | ||
712 | execute get(g:, 'plug_window', 'vertical topleft new') | ||
713 | endfunction | ||
714 | |||
715 | function! s:plug_window_exists() | ||
716 | let buflist = tabpagebuflist(s:plug_tab) | ||
717 | return !empty(buflist) && index(buflist, s:plug_buf) >= 0 | ||
718 | endfunction | ||
719 | |||
720 | function! s:switch_in() | ||
721 | if !s:plug_window_exists() | ||
722 | return 0 | ||
723 | endif | ||
724 | |||
725 | if winbufnr(0) != s:plug_buf | ||
726 | let s:pos = [tabpagenr(), winnr(), winsaveview()] | ||
727 | execute 'normal!' s:plug_tab.'gt' | ||
728 | let winnr = bufwinnr(s:plug_buf) | ||
729 | execute winnr.'wincmd w' | ||
730 | call add(s:pos, winsaveview()) | ||
731 | else | ||
732 | let s:pos = [winsaveview()] | ||
733 | endif | ||
734 | |||
735 | setlocal modifiable | ||
736 | return 1 | ||
737 | endfunction | ||
738 | |||
739 | function! s:switch_out(...) | ||
740 | call winrestview(s:pos[-1]) | ||
741 | setlocal nomodifiable | ||
742 | if a:0 > 0 | ||
743 | execute a:1 | ||
744 | endif | ||
745 | |||
746 | if len(s:pos) > 1 | ||
747 | execute 'normal!' s:pos[0].'gt' | ||
748 | execute s:pos[1] 'wincmd w' | ||
749 | call winrestview(s:pos[2]) | ||
750 | endif | ||
751 | endfunction | ||
752 | |||
753 | function! s:finish_bindings() | ||
754 | nnoremap <silent> <buffer> R :call <SID>retry()<cr> | ||
755 | nnoremap <silent> <buffer> D :PlugDiff<cr> | ||
756 | nnoremap <silent> <buffer> S :PlugStatus<cr> | ||
757 | nnoremap <silent> <buffer> U :call <SID>status_update()<cr> | ||
758 | xnoremap <silent> <buffer> U :call <SID>status_update()<cr> | ||
759 | nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr> | ||
760 | nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr> | ||
761 | endfunction | ||
762 | |||
763 | function! s:prepare(...) | ||
764 | if empty(getcwd()) | ||
765 | throw 'Invalid current working directory. Cannot proceed.' | ||
766 | endif | ||
767 | |||
768 | for evar in ['$GIT_DIR', '$GIT_WORK_TREE'] | ||
769 | if exists(evar) | ||
770 | throw evar.' detected. Cannot proceed.' | ||
771 | endif | ||
772 | endfor | ||
773 | |||
774 | call s:job_abort() | ||
775 | if s:switch_in() | ||
776 | if b:plug_preview == 1 | ||
777 | pc | ||
778 | endif | ||
779 | enew | ||
780 | else | ||
781 | call s:new_window() | ||
782 | endif | ||
783 | |||
784 | nnoremap <silent> <buffer> q :if b:plug_preview==1<bar>pc<bar>endif<bar>bd<cr> | ||
785 | if a:0 == 0 | ||
786 | call s:finish_bindings() | ||
787 | endif | ||
788 | let b:plug_preview = -1 | ||
789 | let s:plug_tab = tabpagenr() | ||
790 | let s:plug_buf = winbufnr(0) | ||
791 | call s:assign_name() | ||
792 | |||
793 | for k in ['<cr>', 'L', 'o', 'X', 'd', 'dd'] | ||
794 | execute 'silent! unmap <buffer>' k | ||
795 | endfor | ||
796 | setlocal buftype=nofile bufhidden=wipe nobuflisted nolist noswapfile nowrap cursorline modifiable nospell | ||
797 | if exists('+colorcolumn') | ||
798 | setlocal colorcolumn= | ||
799 | endif | ||
800 | setf vim-plug | ||
801 | if exists('g:syntax_on') | ||
802 | call s:syntax() | ||
803 | endif | ||
804 | endfunction | ||
805 | |||
806 | function! s:assign_name() | ||
807 | " Assign buffer name | ||
808 | let prefix = '[Plugins]' | ||
809 | let name = prefix | ||
810 | let idx = 2 | ||
811 | while bufexists(name) | ||
812 | let name = printf('%s (%s)', prefix, idx) | ||
813 | let idx = idx + 1 | ||
814 | endwhile | ||
815 | silent! execute 'f' fnameescape(name) | ||
816 | endfunction | ||
817 | |||
818 | function! s:chsh(swap) | ||
819 | let prev = [&shell, &shellcmdflag, &shellredir] | ||
820 | if !s:is_win && a:swap | ||
821 | set shell=sh shellredir=>%s\ 2>&1 | ||
822 | endif | ||
823 | return prev | ||
824 | endfunction | ||
825 | |||
826 | function! s:bang(cmd, ...) | ||
827 | try | ||
828 | let [sh, shellcmdflag, shrd] = s:chsh(a:0) | ||
829 | " FIXME: Escaping is incomplete. We could use shellescape with eval, | ||
830 | " but it won't work on Windows. | ||
831 | let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd | ||
832 | if s:is_win | ||
833 | let [batchfile, cmd] = s:batchfile(cmd) | ||
834 | endif | ||
835 | let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%') | ||
836 | execute "normal! :execute g:_plug_bang\<cr>\<cr>" | ||
837 | finally | ||
838 | unlet g:_plug_bang | ||
839 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] | ||
840 | if s:is_win | ||
841 | call delete(batchfile) | ||
842 | endif | ||
843 | endtry | ||
844 | return v:shell_error ? 'Exit status: ' . v:shell_error : '' | ||
845 | endfunction | ||
846 | |||
847 | function! s:regress_bar() | ||
848 | let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '') | ||
849 | call s:progress_bar(2, bar, len(bar)) | ||
850 | endfunction | ||
851 | |||
852 | function! s:is_updated(dir) | ||
853 | return !empty(s:system_chomp('git log --pretty=format:"%h" "HEAD...HEAD@{1}"', a:dir)) | ||
854 | endfunction | ||
855 | |||
856 | function! s:do(pull, force, todo) | ||
857 | for [name, spec] in items(a:todo) | ||
858 | if !isdirectory(spec.dir) | ||
859 | continue | ||
860 | endif | ||
861 | let installed = has_key(s:update.new, name) | ||
862 | let updated = installed ? 0 : | ||
863 | \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir)) | ||
864 | if a:force || installed || updated | ||
865 | execute 'cd' s:esc(spec.dir) | ||
866 | call append(3, '- Post-update hook for '. name .' ... ') | ||
867 | let error = '' | ||
868 | let type = type(spec.do) | ||
869 | if type == s:TYPE.string | ||
870 | if spec.do[0] == ':' | ||
871 | if !get(s:loaded, name, 0) | ||
872 | let s:loaded[name] = 1 | ||
873 | call s:reorg_rtp() | ||
874 | endif | ||
875 | call s:load_plugin(spec) | ||
876 | try | ||
877 | execute spec.do[1:] | ||
878 | catch | ||
879 | let error = v:exception | ||
880 | endtry | ||
881 | if !s:plug_window_exists() | ||
882 | cd - | ||
883 | throw 'Warning: vim-plug was terminated by the post-update hook of '.name | ||
884 | endif | ||
885 | else | ||
886 | let error = s:bang(spec.do) | ||
887 | endif | ||
888 | elseif type == s:TYPE.funcref | ||
889 | try | ||
890 | let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged') | ||
891 | call spec.do({ 'name': name, 'status': status, 'force': a:force }) | ||
892 | catch | ||
893 | let error = v:exception | ||
894 | endtry | ||
895 | else | ||
896 | let error = 'Invalid hook type' | ||
897 | endif | ||
898 | call s:switch_in() | ||
899 | call setline(4, empty(error) ? (getline(4) . 'OK') | ||
900 | \ : ('x' . getline(4)[1:] . error)) | ||
901 | if !empty(error) | ||
902 | call add(s:update.errors, name) | ||
903 | call s:regress_bar() | ||
904 | endif | ||
905 | cd - | ||
906 | endif | ||
907 | endfor | ||
908 | endfunction | ||
909 | |||
910 | function! s:hash_match(a, b) | ||
911 | return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0 | ||
912 | endfunction | ||
913 | |||
914 | function! s:checkout(spec) | ||
915 | let sha = a:spec.commit | ||
916 | let output = s:system('git rev-parse HEAD', a:spec.dir) | ||
917 | if !v:shell_error && !s:hash_match(sha, s:lines(output)[0]) | ||
918 | let output = s:system( | ||
919 | \ 'git fetch --depth 999999 && git checkout '.s:esc(sha).' --', a:spec.dir) | ||
920 | endif | ||
921 | return output | ||
922 | endfunction | ||
923 | |||
924 | function! s:finish(pull) | ||
925 | let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen')) | ||
926 | if new_frozen | ||
927 | let s = new_frozen > 1 ? 's' : '' | ||
928 | call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s)) | ||
929 | endif | ||
930 | call append(3, '- Finishing ... ') | 4 | ||
931 | redraw | ||
932 | call plug#helptags() | ||
933 | call plug#end() | ||
934 | call setline(4, getline(4) . 'Done!') | ||
935 | redraw | ||
936 | let msgs = [] | ||
937 | if !empty(s:update.errors) | ||
938 | call add(msgs, "Press 'R' to retry.") | ||
939 | endif | ||
940 | if a:pull && len(s:update.new) < len(filter(getline(5, '$'), | ||
941 | \ "v:val =~ '^- ' && v:val !~# 'Already up.to.date'")) | ||
942 | call add(msgs, "Press 'D' to see the updated changes.") | ||
943 | endif | ||
944 | echo join(msgs, ' ') | ||
945 | call s:finish_bindings() | ||
946 | endfunction | ||
947 | |||
948 | function! s:retry() | ||
949 | if empty(s:update.errors) | ||
950 | return | ||
951 | endif | ||
952 | echo | ||
953 | call s:update_impl(s:update.pull, s:update.force, | ||
954 | \ extend(copy(s:update.errors), [s:update.threads])) | ||
955 | endfunction | ||
956 | |||
957 | function! s:is_managed(name) | ||
958 | return has_key(g:plugs[a:name], 'uri') | ||
959 | endfunction | ||
960 | |||
961 | function! s:names(...) | ||
962 | return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)')) | ||
963 | endfunction | ||
964 | |||
965 | function! s:check_ruby() | ||
966 | silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'") | ||
967 | if !exists('g:plug_ruby') | ||
968 | redraw! | ||
969 | return s:warn('echom', 'Warning: Ruby interface is broken') | ||
970 | endif | ||
971 | let ruby_version = split(g:plug_ruby, '\.') | ||
972 | unlet g:plug_ruby | ||
973 | return s:version_requirement(ruby_version, [1, 8, 7]) | ||
974 | endfunction | ||
975 | |||
976 | function! s:update_impl(pull, force, args) abort | ||
977 | let sync = index(a:args, '--sync') >= 0 || has('vim_starting') | ||
978 | let args = filter(copy(a:args), 'v:val != "--sync"') | ||
979 | let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ? | ||
980 | \ remove(args, -1) : get(g:, 'plug_threads', 16) | ||
981 | |||
982 | let managed = filter(copy(g:plugs), 's:is_managed(v:key)') | ||
983 | let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') : | ||
984 | \ filter(managed, 'index(args, v:key) >= 0') | ||
985 | |||
986 | if empty(todo) | ||
987 | return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install')) | ||
988 | endif | ||
989 | |||
990 | if !s:is_win && s:git_version_requirement(2, 3) | ||
991 | let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : '' | ||
992 | let $GIT_TERMINAL_PROMPT = 0 | ||
993 | for plug in values(todo) | ||
994 | let plug.uri = substitute(plug.uri, | ||
995 | \ '^https://git::@github\.com', 'https://github.com', '') | ||
996 | endfor | ||
997 | endif | ||
998 | |||
999 | if !isdirectory(g:plug_home) | ||
1000 | try | ||
1001 | call mkdir(g:plug_home, 'p') | ||
1002 | catch | ||
1003 | return s:err(printf('Invalid plug directory: %s. '. | ||
1004 | \ 'Try to call plug#begin with a valid directory', g:plug_home)) | ||
1005 | endtry | ||
1006 | endif | ||
1007 | |||
1008 | if has('nvim') && !exists('*jobwait') && threads > 1 | ||
1009 | call s:warn('echom', '[vim-plug] Update Neovim for parallel installer') | ||
1010 | endif | ||
1011 | |||
1012 | let use_job = s:nvim || s:vim8 | ||
1013 | let python = (has('python') || has('python3')) && !use_job | ||
1014 | 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() | ||
1015 | |||
1016 | let s:update = { | ||
1017 | \ 'start': reltime(), | ||
1018 | \ 'all': todo, | ||
1019 | \ 'todo': copy(todo), | ||
1020 | \ 'errors': [], | ||
1021 | \ 'pull': a:pull, | ||
1022 | \ 'force': a:force, | ||
1023 | \ 'new': {}, | ||
1024 | \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1, | ||
1025 | \ 'bar': '', | ||
1026 | \ 'fin': 0 | ||
1027 | \ } | ||
1028 | |||
1029 | call s:prepare(1) | ||
1030 | call append(0, ['', '']) | ||
1031 | normal! 2G | ||
1032 | silent! redraw | ||
1033 | |||
1034 | let s:clone_opt = get(g:, 'plug_shallow', 1) ? | ||
1035 | \ '--depth 1' . (s:git_version_requirement(1, 7, 10) ? ' --no-single-branch' : '') : '' | ||
1036 | |||
1037 | if has('win32unix') | ||
1038 | let s:clone_opt .= ' -c core.eol=lf -c core.autocrlf=input' | ||
1039 | endif | ||
1040 | |||
1041 | let s:submodule_opt = s:git_version_requirement(2, 8) ? ' --jobs='.threads : '' | ||
1042 | |||
1043 | " Python version requirement (>= 2.7) | ||
1044 | if python && !has('python3') && !ruby && !use_job && s:update.threads > 1 | ||
1045 | redir => pyv | ||
1046 | silent python import platform; print platform.python_version() | ||
1047 | redir END | ||
1048 | let python = s:version_requirement( | ||
1049 | \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6]) | ||
1050 | endif | ||
1051 | |||
1052 | if (python || ruby) && s:update.threads > 1 | ||
1053 | try | ||
1054 | let imd = &imd | ||
1055 | if s:mac_gui | ||
1056 | set noimd | ||
1057 | endif | ||
1058 | if ruby | ||
1059 | call s:update_ruby() | ||
1060 | else | ||
1061 | call s:update_python() | ||
1062 | endif | ||
1063 | catch | ||
1064 | let lines = getline(4, '$') | ||
1065 | let printed = {} | ||
1066 | silent! 4,$d _ | ||
1067 | for line in lines | ||
1068 | let name = s:extract_name(line, '.', '') | ||
1069 | if empty(name) || !has_key(printed, name) | ||
1070 | call append('$', line) | ||
1071 | if !empty(name) | ||
1072 | let printed[name] = 1 | ||
1073 | if line[0] == 'x' && index(s:update.errors, name) < 0 | ||
1074 | call add(s:update.errors, name) | ||
1075 | end | ||
1076 | endif | ||
1077 | endif | ||
1078 | endfor | ||
1079 | finally | ||
1080 | let &imd = imd | ||
1081 | call s:update_finish() | ||
1082 | endtry | ||
1083 | else | ||
1084 | call s:update_vim() | ||
1085 | while use_job && sync | ||
1086 | sleep 100m | ||
1087 | if s:update.fin | ||
1088 | break | ||
1089 | endif | ||
1090 | endwhile | ||
1091 | endif | ||
1092 | endfunction | ||
1093 | |||
1094 | function! s:log4(name, msg) | ||
1095 | call setline(4, printf('- %s (%s)', a:msg, a:name)) | ||
1096 | redraw | ||
1097 | endfunction | ||
1098 | |||
1099 | function! s:update_finish() | ||
1100 | if exists('s:git_terminal_prompt') | ||
1101 | let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt | ||
1102 | endif | ||
1103 | if s:switch_in() | ||
1104 | call append(3, '- Updating ...') | 4 | ||
1105 | 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))')) | ||
1106 | let [pos, _] = s:logpos(name) | ||
1107 | if !pos | ||
1108 | continue | ||
1109 | endif | ||
1110 | if has_key(spec, 'commit') | ||
1111 | call s:log4(name, 'Checking out '.spec.commit) | ||
1112 | let out = s:checkout(spec) | ||
1113 | elseif has_key(spec, 'tag') | ||
1114 | let tag = spec.tag | ||
1115 | if tag =~ '\*' | ||
1116 | let tags = s:lines(s:system('git tag --list '.plug#shellescape(tag).' --sort -version:refname 2>&1', spec.dir)) | ||
1117 | if !v:shell_error && !empty(tags) | ||
1118 | let tag = tags[0] | ||
1119 | call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag)) | ||
1120 | call append(3, '') | ||
1121 | endif | ||
1122 | endif | ||
1123 | call s:log4(name, 'Checking out '.tag) | ||
1124 | let out = s:system('git checkout -q '.s:esc(tag).' -- 2>&1', spec.dir) | ||
1125 | else | ||
1126 | let branch = s:esc(get(spec, 'branch', 'master')) | ||
1127 | call s:log4(name, 'Merging origin/'.branch) | ||
1128 | let out = s:system('git checkout -q '.branch.' -- 2>&1' | ||
1129 | \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only origin/'.branch.' 2>&1')), spec.dir) | ||
1130 | endif | ||
1131 | if !v:shell_error && filereadable(spec.dir.'/.gitmodules') && | ||
1132 | \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir)) | ||
1133 | call s:log4(name, 'Updating submodules. This may take a while.') | ||
1134 | let out .= s:bang('git submodule update --init --recursive'.s:submodule_opt.' 2>&1', spec.dir) | ||
1135 | endif | ||
1136 | let msg = s:format_message(v:shell_error ? 'x': '-', name, out) | ||
1137 | if v:shell_error | ||
1138 | call add(s:update.errors, name) | ||
1139 | call s:regress_bar() | ||
1140 | silent execute pos 'd _' | ||
1141 | call append(4, msg) | 4 | ||
1142 | elseif !empty(out) | ||
1143 | call setline(pos, msg[0]) | ||
1144 | endif | ||
1145 | redraw | ||
1146 | endfor | ||
1147 | silent 4 d _ | ||
1148 | try | ||
1149 | 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")')) | ||
1150 | catch | ||
1151 | call s:warn('echom', v:exception) | ||
1152 | call s:warn('echo', '') | ||
1153 | return | ||
1154 | endtry | ||
1155 | call s:finish(s:update.pull) | ||
1156 | call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.') | ||
1157 | call s:switch_out('normal! gg') | ||
1158 | endif | ||
1159 | endfunction | ||
1160 | |||
1161 | function! s:job_abort() | ||
1162 | if (!s:nvim && !s:vim8) || !exists('s:jobs') | ||
1163 | return | ||
1164 | endif | ||
1165 | |||
1166 | for [name, j] in items(s:jobs) | ||
1167 | if s:nvim | ||
1168 | silent! call jobstop(j.jobid) | ||
1169 | elseif s:vim8 | ||
1170 | silent! call job_stop(j.jobid) | ||
1171 | endif | ||
1172 | if j.new | ||
1173 | call s:system('rm -rf ' . plug#shellescape(g:plugs[name].dir)) | ||
1174 | endif | ||
1175 | endfor | ||
1176 | let s:jobs = {} | ||
1177 | endfunction | ||
1178 | |||
1179 | function! s:last_non_empty_line(lines) | ||
1180 | let len = len(a:lines) | ||
1181 | for idx in range(len) | ||
1182 | let line = a:lines[len-idx-1] | ||
1183 | if !empty(line) | ||
1184 | return line | ||
1185 | endif | ||
1186 | endfor | ||
1187 | return '' | ||
1188 | endfunction | ||
1189 | |||
1190 | function! s:job_out_cb(self, data) abort | ||
1191 | let self = a:self | ||
1192 | let data = remove(self.lines, -1) . a:data | ||
1193 | let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]') | ||
1194 | call extend(self.lines, lines) | ||
1195 | " To reduce the number of buffer updates | ||
1196 | let self.tick = get(self, 'tick', -1) + 1 | ||
1197 | if !self.running || self.tick % len(s:jobs) == 0 | ||
1198 | let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-') | ||
1199 | let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines) | ||
1200 | call s:log(bullet, self.name, result) | ||
1201 | endif | ||
1202 | endfunction | ||
1203 | |||
1204 | function! s:job_exit_cb(self, data) abort | ||
1205 | let a:self.running = 0 | ||
1206 | let a:self.error = a:data != 0 | ||
1207 | call s:reap(a:self.name) | ||
1208 | call s:tick() | ||
1209 | endfunction | ||
1210 | |||
1211 | function! s:job_cb(fn, job, ch, data) | ||
1212 | if !s:plug_window_exists() " plug window closed | ||
1213 | return s:job_abort() | ||
1214 | endif | ||
1215 | call call(a:fn, [a:job, a:data]) | ||
1216 | endfunction | ||
1217 | |||
1218 | function! s:nvim_cb(job_id, data, event) dict abort | ||
1219 | return a:event == 'stdout' ? | ||
1220 | \ s:job_cb('s:job_out_cb', self, 0, join(a:data, "\n")) : | ||
1221 | \ s:job_cb('s:job_exit_cb', self, 0, a:data) | ||
1222 | endfunction | ||
1223 | |||
1224 | function! s:spawn(name, cmd, opts) | ||
1225 | let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''], | ||
1226 | \ 'new': get(a:opts, 'new', 0) } | ||
1227 | let s:jobs[a:name] = job | ||
1228 | let cmd = has_key(a:opts, 'dir') ? s:with_cd(a:cmd, a:opts.dir, 0) : a:cmd | ||
1229 | let argv = s:is_win ? ['cmd', '/s', '/c', '"'.cmd.'"'] : ['sh', '-c', cmd] | ||
1230 | |||
1231 | if s:nvim | ||
1232 | call extend(job, { | ||
1233 | \ 'on_stdout': function('s:nvim_cb'), | ||
1234 | \ 'on_exit': function('s:nvim_cb'), | ||
1235 | \ }) | ||
1236 | let jid = jobstart(argv, job) | ||
1237 | if jid > 0 | ||
1238 | let job.jobid = jid | ||
1239 | else | ||
1240 | let job.running = 0 | ||
1241 | let job.error = 1 | ||
1242 | let job.lines = [jid < 0 ? argv[0].' is not executable' : | ||
1243 | \ 'Invalid arguments (or job table is full)'] | ||
1244 | endif | ||
1245 | elseif s:vim8 | ||
1246 | let jid = job_start(s:is_win ? join(argv, ' ') : argv, { | ||
1247 | \ 'out_cb': function('s:job_cb', ['s:job_out_cb', job]), | ||
1248 | \ 'exit_cb': function('s:job_cb', ['s:job_exit_cb', job]), | ||
1249 | \ 'out_mode': 'raw' | ||
1250 | \}) | ||
1251 | if job_status(jid) == 'run' | ||
1252 | let job.jobid = jid | ||
1253 | else | ||
1254 | let job.running = 0 | ||
1255 | let job.error = 1 | ||
1256 | let job.lines = ['Failed to start job'] | ||
1257 | endif | ||
1258 | else | ||
1259 | let job.lines = s:lines(call('s:system', [cmd])) | ||
1260 | let job.error = v:shell_error != 0 | ||
1261 | let job.running = 0 | ||
1262 | endif | ||
1263 | endfunction | ||
1264 | |||
1265 | function! s:reap(name) | ||
1266 | let job = s:jobs[a:name] | ||
1267 | if job.error | ||
1268 | call add(s:update.errors, a:name) | ||
1269 | elseif get(job, 'new', 0) | ||
1270 | let s:update.new[a:name] = 1 | ||
1271 | endif | ||
1272 | let s:update.bar .= job.error ? 'x' : '=' | ||
1273 | |||
1274 | let bullet = job.error ? 'x' : '-' | ||
1275 | let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines) | ||
1276 | call s:log(bullet, a:name, empty(result) ? 'OK' : result) | ||
1277 | call s:bar() | ||
1278 | |||
1279 | call remove(s:jobs, a:name) | ||
1280 | endfunction | ||
1281 | |||
1282 | function! s:bar() | ||
1283 | if s:switch_in() | ||
1284 | let total = len(s:update.all) | ||
1285 | call setline(1, (s:update.pull ? 'Updating' : 'Installing'). | ||
1286 | \ ' plugins ('.len(s:update.bar).'/'.total.')') | ||
1287 | call s:progress_bar(2, s:update.bar, total) | ||
1288 | call s:switch_out() | ||
1289 | endif | ||
1290 | endfunction | ||
1291 | |||
1292 | function! s:logpos(name) | ||
1293 | for i in range(4, line('$')) | ||
1294 | if getline(i) =~# '^[-+x*] '.a:name.':' | ||
1295 | for j in range(i + 1, line('$')) | ||
1296 | if getline(j) !~ '^ ' | ||
1297 | return [i, j - 1] | ||
1298 | endif | ||
1299 | endfor | ||
1300 | return [i, i] | ||
1301 | endif | ||
1302 | endfor | ||
1303 | return [0, 0] | ||
1304 | endfunction | ||
1305 | |||
1306 | function! s:log(bullet, name, lines) | ||
1307 | if s:switch_in() | ||
1308 | let [b, e] = s:logpos(a:name) | ||
1309 | if b > 0 | ||
1310 | silent execute printf('%d,%d d _', b, e) | ||
1311 | if b > winheight('.') | ||
1312 | let b = 4 | ||
1313 | endif | ||
1314 | else | ||
1315 | let b = 4 | ||
1316 | endif | ||
1317 | " FIXME For some reason, nomodifiable is set after :d in vim8 | ||
1318 | setlocal modifiable | ||
1319 | call append(b - 1, s:format_message(a:bullet, a:name, a:lines)) | ||
1320 | call s:switch_out() | ||
1321 | endif | ||
1322 | endfunction | ||
1323 | |||
1324 | function! s:update_vim() | ||
1325 | let s:jobs = {} | ||
1326 | |||
1327 | call s:bar() | ||
1328 | call s:tick() | ||
1329 | endfunction | ||
1330 | |||
1331 | function! s:tick() | ||
1332 | let pull = s:update.pull | ||
1333 | let prog = s:progress_opt(s:nvim || s:vim8) | ||
1334 | while 1 " Without TCO, Vim stack is bound to explode | ||
1335 | if empty(s:update.todo) | ||
1336 | if empty(s:jobs) && !s:update.fin | ||
1337 | call s:update_finish() | ||
1338 | let s:update.fin = 1 | ||
1339 | endif | ||
1340 | return | ||
1341 | endif | ||
1342 | |||
1343 | let name = keys(s:update.todo)[0] | ||
1344 | let spec = remove(s:update.todo, name) | ||
1345 | let new = empty(globpath(spec.dir, '.git', 1)) | ||
1346 | |||
1347 | call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...') | ||
1348 | redraw | ||
1349 | |||
1350 | let has_tag = has_key(spec, 'tag') | ||
1351 | if !new | ||
1352 | let [error, _] = s:git_validate(spec, 0) | ||
1353 | if empty(error) | ||
1354 | if pull | ||
1355 | let fetch_opt = (has_tag && !empty(globpath(spec.dir, '.git/shallow'))) ? '--depth 99999999' : '' | ||
1356 | call s:spawn(name, printf('git fetch %s %s 2>&1', fetch_opt, prog), { 'dir': spec.dir }) | ||
1357 | else | ||
1358 | let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 } | ||
1359 | endif | ||
1360 | else | ||
1361 | let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 } | ||
1362 | endif | ||
1363 | else | ||
1364 | call s:spawn(name, | ||
1365 | \ printf('git clone %s %s %s %s 2>&1', | ||
1366 | \ has_tag ? '' : s:clone_opt, | ||
1367 | \ prog, | ||
1368 | \ plug#shellescape(spec.uri, {'script': 0}), | ||
1369 | \ plug#shellescape(s:trim(spec.dir), {'script': 0})), { 'new': 1 }) | ||
1370 | endif | ||
1371 | |||
1372 | if !s:jobs[name].running | ||
1373 | call s:reap(name) | ||
1374 | endif | ||
1375 | if len(s:jobs) >= s:update.threads | ||
1376 | break | ||
1377 | endif | ||
1378 | endwhile | ||
1379 | endfunction | ||
1380 | |||
1381 | function! s:update_python() | ||
1382 | let py_exe = has('python') ? 'python' : 'python3' | ||
1383 | execute py_exe "<< EOF" | ||
1384 | import datetime | ||
1385 | import functools | ||
1386 | import os | ||
1387 | try: | ||
1388 | import queue | ||
1389 | except ImportError: | ||
1390 | import Queue as queue | ||
1391 | import random | ||
1392 | import re | ||
1393 | import shutil | ||
1394 | import signal | ||
1395 | import subprocess | ||
1396 | import tempfile | ||
1397 | import threading as thr | ||
1398 | import time | ||
1399 | import traceback | ||
1400 | import vim | ||
1401 | |||
1402 | G_NVIM = vim.eval("has('nvim')") == '1' | ||
1403 | G_PULL = vim.eval('s:update.pull') == '1' | ||
1404 | G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1 | ||
1405 | G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)')) | ||
1406 | G_CLONE_OPT = vim.eval('s:clone_opt') | ||
1407 | G_PROGRESS = vim.eval('s:progress_opt(1)') | ||
1408 | G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads')) | ||
1409 | G_STOP = thr.Event() | ||
1410 | G_IS_WIN = vim.eval('s:is_win') == '1' | ||
1411 | |||
1412 | class PlugError(Exception): | ||
1413 | def __init__(self, msg): | ||
1414 | self.msg = msg | ||
1415 | class CmdTimedOut(PlugError): | ||
1416 | pass | ||
1417 | class CmdFailed(PlugError): | ||
1418 | pass | ||
1419 | class InvalidURI(PlugError): | ||
1420 | pass | ||
1421 | class Action(object): | ||
1422 | INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-'] | ||
1423 | |||
1424 | class Buffer(object): | ||
1425 | def __init__(self, lock, num_plugs, is_pull): | ||
1426 | self.bar = '' | ||
1427 | self.event = 'Updating' if is_pull else 'Installing' | ||
1428 | self.lock = lock | ||
1429 | self.maxy = int(vim.eval('winheight(".")')) | ||
1430 | self.num_plugs = num_plugs | ||
1431 | |||
1432 | def __where(self, name): | ||
1433 | """ Find first line with name in current buffer. Return line num. """ | ||
1434 | found, lnum = False, 0 | ||
1435 | matcher = re.compile('^[-+x*] {0}:'.format(name)) | ||
1436 | for line in vim.current.buffer: | ||
1437 | if matcher.search(line) is not None: | ||
1438 | found = True | ||
1439 | break | ||
1440 | lnum += 1 | ||
1441 | |||
1442 | if not found: | ||
1443 | lnum = -1 | ||
1444 | return lnum | ||
1445 | |||
1446 | def header(self): | ||
1447 | curbuf = vim.current.buffer | ||
1448 | curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs) | ||
1449 | |||
1450 | num_spaces = self.num_plugs - len(self.bar) | ||
1451 | curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ') | ||
1452 | |||
1453 | with self.lock: | ||
1454 | vim.command('normal! 2G') | ||
1455 | vim.command('redraw') | ||
1456 | |||
1457 | def write(self, action, name, lines): | ||
1458 | first, rest = lines[0], lines[1:] | ||
1459 | msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)] | ||
1460 | msg.extend([' ' + line for line in rest]) | ||
1461 | |||
1462 | try: | ||
1463 | if action == Action.ERROR: | ||
1464 | self.bar += 'x' | ||
1465 | vim.command("call add(s:update.errors, '{0}')".format(name)) | ||
1466 | elif action == Action.DONE: | ||
1467 | self.bar += '=' | ||
1468 | |||
1469 | curbuf = vim.current.buffer | ||
1470 | lnum = self.__where(name) | ||
1471 | if lnum != -1: # Found matching line num | ||
1472 | del curbuf[lnum] | ||
1473 | if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]): | ||
1474 | lnum = 3 | ||
1475 | else: | ||
1476 | lnum = 3 | ||
1477 | curbuf.append(msg, lnum) | ||
1478 | |||
1479 | self.header() | ||
1480 | except vim.error: | ||
1481 | pass | ||
1482 | |||
1483 | class Command(object): | ||
1484 | CD = 'cd /d' if G_IS_WIN else 'cd' | ||
1485 | |||
1486 | def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None): | ||
1487 | self.cmd = cmd | ||
1488 | if cmd_dir: | ||
1489 | self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd) | ||
1490 | self.timeout = timeout | ||
1491 | self.callback = cb if cb else (lambda msg: None) | ||
1492 | self.clean = clean if clean else (lambda: None) | ||
1493 | self.proc = None | ||
1494 | |||
1495 | @property | ||
1496 | def alive(self): | ||
1497 | """ Returns true only if command still running. """ | ||
1498 | return self.proc and self.proc.poll() is None | ||
1499 | |||
1500 | def execute(self, ntries=3): | ||
1501 | """ Execute the command with ntries if CmdTimedOut. | ||
1502 | Returns the output of the command if no Exception. | ||
1503 | """ | ||
1504 | attempt, finished, limit = 0, False, self.timeout | ||
1505 | |||
1506 | while not finished: | ||
1507 | try: | ||
1508 | attempt += 1 | ||
1509 | result = self.try_command() | ||
1510 | finished = True | ||
1511 | return result | ||
1512 | except CmdTimedOut: | ||
1513 | if attempt != ntries: | ||
1514 | self.notify_retry() | ||
1515 | self.timeout += limit | ||
1516 | else: | ||
1517 | raise | ||
1518 | |||
1519 | def notify_retry(self): | ||
1520 | """ Retry required for command, notify user. """ | ||
1521 | for count in range(3, 0, -1): | ||
1522 | if G_STOP.is_set(): | ||
1523 | raise KeyboardInterrupt | ||
1524 | msg = 'Timeout. Will retry in {0} second{1} ...'.format( | ||
1525 | count, 's' if count != 1 else '') | ||
1526 | self.callback([msg]) | ||
1527 | time.sleep(1) | ||
1528 | self.callback(['Retrying ...']) | ||
1529 | |||
1530 | def try_command(self): | ||
1531 | """ Execute a cmd & poll for callback. Returns list of output. | ||
1532 | Raises CmdFailed -> return code for Popen isn't 0 | ||
1533 | Raises CmdTimedOut -> command exceeded timeout without new output | ||
1534 | """ | ||
1535 | first_line = True | ||
1536 | |||
1537 | try: | ||
1538 | tfile = tempfile.NamedTemporaryFile(mode='w+b') | ||
1539 | preexec_fn = not G_IS_WIN and os.setsid or None | ||
1540 | self.proc = subprocess.Popen(self.cmd, stdout=tfile, | ||
1541 | stderr=subprocess.STDOUT, | ||
1542 | stdin=subprocess.PIPE, shell=True, | ||
1543 | preexec_fn=preexec_fn) | ||
1544 | thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,)) | ||
1545 | thrd.start() | ||
1546 | |||
1547 | thread_not_started = True | ||
1548 | while thread_not_started: | ||
1549 | try: | ||
1550 | thrd.join(0.1) | ||
1551 | thread_not_started = False | ||
1552 | except RuntimeError: | ||
1553 | pass | ||
1554 | |||
1555 | while self.alive: | ||
1556 | if G_STOP.is_set(): | ||
1557 | raise KeyboardInterrupt | ||
1558 | |||
1559 | if first_line or random.random() < G_LOG_PROB: | ||
1560 | first_line = False | ||
1561 | line = '' if G_IS_WIN else nonblock_read(tfile.name) | ||
1562 | if line: | ||
1563 | self.callback([line]) | ||
1564 | |||
1565 | time_diff = time.time() - os.path.getmtime(tfile.name) | ||
1566 | if time_diff > self.timeout: | ||
1567 | raise CmdTimedOut(['Timeout!']) | ||
1568 | |||
1569 | thrd.join(0.5) | ||
1570 | |||
1571 | tfile.seek(0) | ||
1572 | result = [line.decode('utf-8', 'replace').rstrip() for line in tfile] | ||
1573 | |||
1574 | if self.proc.returncode != 0: | ||
1575 | raise CmdFailed([''] + result) | ||
1576 | |||
1577 | return result | ||
1578 | except: | ||
1579 | self.terminate() | ||
1580 | raise | ||
1581 | |||
1582 | def terminate(self): | ||
1583 | """ Terminate process and cleanup. """ | ||
1584 | if self.alive: | ||
1585 | if G_IS_WIN: | ||
1586 | os.kill(self.proc.pid, signal.SIGINT) | ||
1587 | else: | ||
1588 | os.killpg(self.proc.pid, signal.SIGTERM) | ||
1589 | self.clean() | ||
1590 | |||
1591 | class Plugin(object): | ||
1592 | def __init__(self, name, args, buf_q, lock): | ||
1593 | self.name = name | ||
1594 | self.args = args | ||
1595 | self.buf_q = buf_q | ||
1596 | self.lock = lock | ||
1597 | self.tag = args.get('tag', 0) | ||
1598 | |||
1599 | def manage(self): | ||
1600 | try: | ||
1601 | if os.path.exists(self.args['dir']): | ||
1602 | self.update() | ||
1603 | else: | ||
1604 | self.install() | ||
1605 | with self.lock: | ||
1606 | thread_vim_command("let s:update.new['{0}'] = 1".format(self.name)) | ||
1607 | except PlugError as exc: | ||
1608 | self.write(Action.ERROR, self.name, exc.msg) | ||
1609 | except KeyboardInterrupt: | ||
1610 | G_STOP.set() | ||
1611 | self.write(Action.ERROR, self.name, ['Interrupted!']) | ||
1612 | except: | ||
1613 | # Any exception except those above print stack trace | ||
1614 | msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip()) | ||
1615 | self.write(Action.ERROR, self.name, msg.split('\n')) | ||
1616 | raise | ||
1617 | |||
1618 | def install(self): | ||
1619 | target = self.args['dir'] | ||
1620 | if target[-1] == '\\': | ||
1621 | target = target[0:-1] | ||
1622 | |||
1623 | def clean(target): | ||
1624 | def _clean(): | ||
1625 | try: | ||
1626 | shutil.rmtree(target) | ||
1627 | except OSError: | ||
1628 | pass | ||
1629 | return _clean | ||
1630 | |||
1631 | self.write(Action.INSTALL, self.name, ['Installing ...']) | ||
1632 | callback = functools.partial(self.write, Action.INSTALL, self.name) | ||
1633 | cmd = 'git clone {0} {1} {2} {3} 2>&1'.format( | ||
1634 | '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'], | ||
1635 | esc(target)) | ||
1636 | com = Command(cmd, None, G_TIMEOUT, callback, clean(target)) | ||
1637 | result = com.execute(G_RETRIES) | ||
1638 | self.write(Action.DONE, self.name, result[-1:]) | ||
1639 | |||
1640 | def repo_uri(self): | ||
1641 | cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url' | ||
1642 | command = Command(cmd, self.args['dir'], G_TIMEOUT,) | ||
1643 | result = command.execute(G_RETRIES) | ||
1644 | return result[-1] | ||
1645 | |||
1646 | def update(self): | ||
1647 | actual_uri = self.repo_uri() | ||
1648 | expect_uri = self.args['uri'] | ||
1649 | regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$') | ||
1650 | ma = regex.match(actual_uri) | ||
1651 | mb = regex.match(expect_uri) | ||
1652 | if ma is None or mb is None or ma.groups() != mb.groups(): | ||
1653 | msg = ['', | ||
1654 | 'Invalid URI: {0}'.format(actual_uri), | ||
1655 | 'Expected {0}'.format(expect_uri), | ||
1656 | 'PlugClean required.'] | ||
1657 | raise InvalidURI(msg) | ||
1658 | |||
1659 | if G_PULL: | ||
1660 | self.write(Action.UPDATE, self.name, ['Updating ...']) | ||
1661 | callback = functools.partial(self.write, Action.UPDATE, self.name) | ||
1662 | fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else '' | ||
1663 | cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS) | ||
1664 | com = Command(cmd, self.args['dir'], G_TIMEOUT, callback) | ||
1665 | result = com.execute(G_RETRIES) | ||
1666 | self.write(Action.DONE, self.name, result[-1:]) | ||
1667 | else: | ||
1668 | self.write(Action.DONE, self.name, ['Already installed']) | ||
1669 | |||
1670 | def write(self, action, name, msg): | ||
1671 | self.buf_q.put((action, name, msg)) | ||
1672 | |||
1673 | class PlugThread(thr.Thread): | ||
1674 | def __init__(self, tname, args): | ||
1675 | super(PlugThread, self).__init__() | ||
1676 | self.tname = tname | ||
1677 | self.args = args | ||
1678 | |||
1679 | def run(self): | ||
1680 | thr.current_thread().name = self.tname | ||
1681 | buf_q, work_q, lock = self.args | ||
1682 | |||
1683 | try: | ||
1684 | while not G_STOP.is_set(): | ||
1685 | name, args = work_q.get_nowait() | ||
1686 | plug = Plugin(name, args, buf_q, lock) | ||
1687 | plug.manage() | ||
1688 | work_q.task_done() | ||
1689 | except queue.Empty: | ||
1690 | pass | ||
1691 | |||
1692 | class RefreshThread(thr.Thread): | ||
1693 | def __init__(self, lock): | ||
1694 | super(RefreshThread, self).__init__() | ||
1695 | self.lock = lock | ||
1696 | self.running = True | ||
1697 | |||
1698 | def run(self): | ||
1699 | while self.running: | ||
1700 | with self.lock: | ||
1701 | thread_vim_command('noautocmd normal! a') | ||
1702 | time.sleep(0.33) | ||
1703 | |||
1704 | def stop(self): | ||
1705 | self.running = False | ||
1706 | |||
1707 | if G_NVIM: | ||
1708 | def thread_vim_command(cmd): | ||
1709 | vim.session.threadsafe_call(lambda: vim.command(cmd)) | ||
1710 | else: | ||
1711 | def thread_vim_command(cmd): | ||
1712 | vim.command(cmd) | ||
1713 | |||
1714 | def esc(name): | ||
1715 | return '"' + name.replace('"', '\"') + '"' | ||
1716 | |||
1717 | def nonblock_read(fname): | ||
1718 | """ Read a file with nonblock flag. Return the last line. """ | ||
1719 | fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK) | ||
1720 | buf = os.read(fread, 100000).decode('utf-8', 'replace') | ||
1721 | os.close(fread) | ||
1722 | |||
1723 | line = buf.rstrip('\r\n') | ||
1724 | left = max(line.rfind('\r'), line.rfind('\n')) | ||
1725 | if left != -1: | ||
1726 | left += 1 | ||
1727 | line = line[left:] | ||
1728 | |||
1729 | return line | ||
1730 | |||
1731 | def main(): | ||
1732 | thr.current_thread().name = 'main' | ||
1733 | nthreads = int(vim.eval('s:update.threads')) | ||
1734 | plugs = vim.eval('s:update.todo') | ||
1735 | mac_gui = vim.eval('s:mac_gui') == '1' | ||
1736 | |||
1737 | lock = thr.Lock() | ||
1738 | buf = Buffer(lock, len(plugs), G_PULL) | ||
1739 | buf_q, work_q = queue.Queue(), queue.Queue() | ||
1740 | for work in plugs.items(): | ||
1741 | work_q.put(work) | ||
1742 | |||
1743 | start_cnt = thr.active_count() | ||
1744 | for num in range(nthreads): | ||
1745 | tname = 'PlugT-{0:02}'.format(num) | ||
1746 | thread = PlugThread(tname, (buf_q, work_q, lock)) | ||
1747 | thread.start() | ||
1748 | if mac_gui: | ||
1749 | rthread = RefreshThread(lock) | ||
1750 | rthread.start() | ||
1751 | |||
1752 | while not buf_q.empty() or thr.active_count() != start_cnt: | ||
1753 | try: | ||
1754 | action, name, msg = buf_q.get(True, 0.25) | ||
1755 | buf.write(action, name, ['OK'] if not msg else msg) | ||
1756 | buf_q.task_done() | ||
1757 | except queue.Empty: | ||
1758 | pass | ||
1759 | except KeyboardInterrupt: | ||
1760 | G_STOP.set() | ||
1761 | |||
1762 | if mac_gui: | ||
1763 | rthread.stop() | ||
1764 | rthread.join() | ||
1765 | |||
1766 | main() | ||
1767 | EOF | ||
1768 | endfunction | ||
1769 | |||
1770 | function! s:update_ruby() | ||
1771 | ruby << EOF | ||
1772 | module PlugStream | ||
1773 | SEP = ["\r", "\n", nil] | ||
1774 | def get_line | ||
1775 | buffer = '' | ||
1776 | loop do | ||
1777 | char = readchar rescue return | ||
1778 | if SEP.include? char.chr | ||
1779 | buffer << $/ | ||
1780 | break | ||
1781 | else | ||
1782 | buffer << char | ||
1783 | end | ||
1784 | end | ||
1785 | buffer | ||
1786 | end | ||
1787 | end unless defined?(PlugStream) | ||
1788 | |||
1789 | def esc arg | ||
1790 | %["#{arg.gsub('"', '\"')}"] | ||
1791 | end | ||
1792 | |||
1793 | def killall pid | ||
1794 | pids = [pid] | ||
1795 | if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM | ||
1796 | pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil } | ||
1797 | else | ||
1798 | unless `which pgrep 2> /dev/null`.empty? | ||
1799 | children = pids | ||
1800 | until children.empty? | ||
1801 | children = children.map { |pid| | ||
1802 | `pgrep -P #{pid}`.lines.map { |l| l.chomp } | ||
1803 | }.flatten | ||
1804 | pids += children | ||
1805 | end | ||
1806 | end | ||
1807 | pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil } | ||
1808 | end | ||
1809 | end | ||
1810 | |||
1811 | def compare_git_uri a, b | ||
1812 | regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$} | ||
1813 | regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1) | ||
1814 | end | ||
1815 | |||
1816 | require 'thread' | ||
1817 | require 'fileutils' | ||
1818 | require 'timeout' | ||
1819 | running = true | ||
1820 | iswin = VIM::evaluate('s:is_win').to_i == 1 | ||
1821 | pull = VIM::evaluate('s:update.pull').to_i == 1 | ||
1822 | base = VIM::evaluate('g:plug_home') | ||
1823 | all = VIM::evaluate('s:update.todo') | ||
1824 | limit = VIM::evaluate('get(g:, "plug_timeout", 60)') | ||
1825 | tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1 | ||
1826 | nthr = VIM::evaluate('s:update.threads').to_i | ||
1827 | maxy = VIM::evaluate('winheight(".")').to_i | ||
1828 | vim7 = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/ | ||
1829 | cd = iswin ? 'cd /d' : 'cd' | ||
1830 | tot = VIM::evaluate('len(s:update.todo)') || 0 | ||
1831 | bar = '' | ||
1832 | skip = 'Already installed' | ||
1833 | mtx = Mutex.new | ||
1834 | take1 = proc { mtx.synchronize { running && all.shift } } | ||
1835 | logh = proc { | ||
1836 | cnt = bar.length | ||
1837 | $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})" | ||
1838 | $curbuf[2] = '[' + bar.ljust(tot) + ']' | ||
1839 | VIM::command('normal! 2G') | ||
1840 | VIM::command('redraw') | ||
1841 | } | ||
1842 | where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } } | ||
1843 | log = proc { |name, result, type| | ||
1844 | mtx.synchronize do | ||
1845 | ing = ![true, false].include?(type) | ||
1846 | bar += type ? '=' : 'x' unless ing | ||
1847 | b = case type | ||
1848 | when :install then '+' when :update then '*' | ||
1849 | when true, nil then '-' else | ||
1850 | VIM::command("call add(s:update.errors, '#{name}')") | ||
1851 | 'x' | ||
1852 | end | ||
1853 | result = | ||
1854 | if type || type.nil? | ||
1855 | ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"] | ||
1856 | elsif result =~ /^Interrupted|^Timeout/ | ||
1857 | ["#{b} #{name}: #{result}"] | ||
1858 | else | ||
1859 | ["#{b} #{name}"] + result.lines.map { |l| " " << l } | ||
1860 | end | ||
1861 | if lnum = where.call(name) | ||
1862 | $curbuf.delete lnum | ||
1863 | lnum = 4 if ing && lnum > maxy | ||
1864 | end | ||
1865 | result.each_with_index do |line, offset| | ||
1866 | $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp) | ||
1867 | end | ||
1868 | logh.call | ||
1869 | end | ||
1870 | } | ||
1871 | bt = proc { |cmd, name, type, cleanup| | ||
1872 | tried = timeout = 0 | ||
1873 | begin | ||
1874 | tried += 1 | ||
1875 | timeout += limit | ||
1876 | fd = nil | ||
1877 | data = '' | ||
1878 | if iswin | ||
1879 | Timeout::timeout(timeout) do | ||
1880 | tmp = VIM::evaluate('tempname()') | ||
1881 | system("(#{cmd}) > #{tmp}") | ||
1882 | data = File.read(tmp).chomp | ||
1883 | File.unlink tmp rescue nil | ||
1884 | end | ||
1885 | else | ||
1886 | fd = IO.popen(cmd).extend(PlugStream) | ||
1887 | first_line = true | ||
1888 | log_prob = 1.0 / nthr | ||
1889 | while line = Timeout::timeout(timeout) { fd.get_line } | ||
1890 | data << line | ||
1891 | log.call name, line.chomp, type if name && (first_line || rand < log_prob) | ||
1892 | first_line = false | ||
1893 | end | ||
1894 | fd.close | ||
1895 | end | ||
1896 | [$? == 0, data.chomp] | ||
1897 | rescue Timeout::Error, Interrupt => e | ||
1898 | if fd && !fd.closed? | ||
1899 | killall fd.pid | ||
1900 | fd.close | ||
1901 | end | ||
1902 | cleanup.call if cleanup | ||
1903 | if e.is_a?(Timeout::Error) && tried < tries | ||
1904 | 3.downto(1) do |countdown| | ||
1905 | s = countdown > 1 ? 's' : '' | ||
1906 | log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type | ||
1907 | sleep 1 | ||
1908 | end | ||
1909 | log.call name, 'Retrying ...', type | ||
1910 | retry | ||
1911 | end | ||
1912 | [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"] | ||
1913 | end | ||
1914 | } | ||
1915 | main = Thread.current | ||
1916 | threads = [] | ||
1917 | watcher = Thread.new { | ||
1918 | if vim7 | ||
1919 | while VIM::evaluate('getchar(1)') | ||
1920 | sleep 0.1 | ||
1921 | end | ||
1922 | else | ||
1923 | require 'io/console' # >= Ruby 1.9 | ||
1924 | nil until IO.console.getch == 3.chr | ||
1925 | end | ||
1926 | mtx.synchronize do | ||
1927 | running = false | ||
1928 | threads.each { |t| t.raise Interrupt } unless vim7 | ||
1929 | end | ||
1930 | threads.each { |t| t.join rescue nil } | ||
1931 | main.kill | ||
1932 | } | ||
1933 | refresh = Thread.new { | ||
1934 | while true | ||
1935 | mtx.synchronize do | ||
1936 | break unless running | ||
1937 | VIM::command('noautocmd normal! a') | ||
1938 | end | ||
1939 | sleep 0.2 | ||
1940 | end | ||
1941 | } if VIM::evaluate('s:mac_gui') == 1 | ||
1942 | |||
1943 | clone_opt = VIM::evaluate('s:clone_opt') | ||
1944 | progress = VIM::evaluate('s:progress_opt(1)') | ||
1945 | nthr.times do | ||
1946 | mtx.synchronize do | ||
1947 | threads << Thread.new { | ||
1948 | while pair = take1.call | ||
1949 | name = pair.first | ||
1950 | dir, uri, tag = pair.last.values_at *%w[dir uri tag] | ||
1951 | exists = File.directory? dir | ||
1952 | ok, result = | ||
1953 | if exists | ||
1954 | chdir = "#{cd} #{iswin ? dir : esc(dir)}" | ||
1955 | ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil | ||
1956 | current_uri = data.lines.to_a.last | ||
1957 | if !ret | ||
1958 | if data =~ /^Interrupted|^Timeout/ | ||
1959 | [false, data] | ||
1960 | else | ||
1961 | [false, [data.chomp, "PlugClean required."].join($/)] | ||
1962 | end | ||
1963 | elsif !compare_git_uri(current_uri, uri) | ||
1964 | [false, ["Invalid URI: #{current_uri}", | ||
1965 | "Expected: #{uri}", | ||
1966 | "PlugClean required."].join($/)] | ||
1967 | else | ||
1968 | if pull | ||
1969 | log.call name, 'Updating ...', :update | ||
1970 | fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : '' | ||
1971 | bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil | ||
1972 | else | ||
1973 | [true, skip] | ||
1974 | end | ||
1975 | end | ||
1976 | else | ||
1977 | d = esc dir.sub(%r{[\\/]+$}, '') | ||
1978 | log.call name, 'Installing ...', :install | ||
1979 | bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc { | ||
1980 | FileUtils.rm_rf dir | ||
1981 | } | ||
1982 | end | ||
1983 | mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok | ||
1984 | log.call name, result, ok | ||
1985 | end | ||
1986 | } if running | ||
1987 | end | ||
1988 | end | ||
1989 | threads.each { |t| t.join rescue nil } | ||
1990 | logh.call | ||
1991 | refresh.kill if refresh | ||
1992 | watcher.kill | ||
1993 | EOF | ||
1994 | endfunction | ||
1995 | |||
1996 | function! s:shellesc_cmd(arg, script) | ||
1997 | let escaped = substitute('"'.a:arg.'"', '[&|<>()@^!"]', '^&', 'g') | ||
1998 | return substitute(escaped, '%', (a:script ? '%' : '^') . '&', 'g') | ||
1999 | endfunction | ||
2000 | |||
2001 | function! s:shellesc_ps1(arg) | ||
2002 | return "'".substitute(escape(a:arg, '\"'), "'", "''", 'g')."'" | ||
2003 | endfunction | ||
2004 | |||
2005 | function! plug#shellescape(arg, ...) | ||
2006 | let opts = a:0 > 0 && type(a:1) == s:TYPE.dict ? a:1 : {} | ||
2007 | let shell = get(opts, 'shell', s:is_win ? 'cmd.exe' : 'sh') | ||
2008 | let script = get(opts, 'script', 1) | ||
2009 | if shell =~# 'cmd\.exe$' | ||
2010 | return s:shellesc_cmd(a:arg, script) | ||
2011 | elseif shell =~# 'powershell\.exe$' || shell =~# 'pwsh$' | ||
2012 | return s:shellesc_ps1(a:arg) | ||
2013 | endif | ||
2014 | return shellescape(a:arg) | ||
2015 | endfunction | ||
2016 | |||
2017 | function! s:glob_dir(path) | ||
2018 | return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)') | ||
2019 | endfunction | ||
2020 | |||
2021 | function! s:progress_bar(line, bar, total) | ||
2022 | call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']') | ||
2023 | endfunction | ||
2024 | |||
2025 | function! s:compare_git_uri(a, b) | ||
2026 | " See `git help clone' | ||
2027 | " https:// [user@] github.com[:port] / junegunn/vim-plug [.git] | ||
2028 | " [git@] github.com[:port] : junegunn/vim-plug [.git] | ||
2029 | " file:// / junegunn/vim-plug [/] | ||
2030 | " / junegunn/vim-plug [/] | ||
2031 | let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$' | ||
2032 | let ma = matchlist(a:a, pat) | ||
2033 | let mb = matchlist(a:b, pat) | ||
2034 | return ma[1:2] ==# mb[1:2] | ||
2035 | endfunction | ||
2036 | |||
2037 | function! s:format_message(bullet, name, message) | ||
2038 | if a:bullet != 'x' | ||
2039 | return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))] | ||
2040 | else | ||
2041 | let lines = map(s:lines(a:message), '" ".v:val') | ||
2042 | return extend([printf('x %s:', a:name)], lines) | ||
2043 | endif | ||
2044 | endfunction | ||
2045 | |||
2046 | function! s:with_cd(cmd, dir, ...) | ||
2047 | let script = a:0 > 0 ? a:1 : 1 | ||
2048 | return printf('cd%s %s && %s', s:is_win ? ' /d' : '', plug#shellescape(a:dir, {'script': script}), a:cmd) | ||
2049 | endfunction | ||
2050 | |||
2051 | function! s:system(cmd, ...) | ||
2052 | try | ||
2053 | let [sh, shellcmdflag, shrd] = s:chsh(1) | ||
2054 | let cmd = a:0 > 0 ? s:with_cd(a:cmd, a:1) : a:cmd | ||
2055 | if s:is_win | ||
2056 | let [batchfile, cmd] = s:batchfile(cmd) | ||
2057 | endif | ||
2058 | return system(cmd) | ||
2059 | finally | ||
2060 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] | ||
2061 | if s:is_win | ||
2062 | call delete(batchfile) | ||
2063 | endif | ||
2064 | endtry | ||
2065 | endfunction | ||
2066 | |||
2067 | function! s:system_chomp(...) | ||
2068 | let ret = call('s:system', a:000) | ||
2069 | return v:shell_error ? '' : substitute(ret, '\n$', '', '') | ||
2070 | endfunction | ||
2071 | |||
2072 | function! s:git_validate(spec, check_branch) | ||
2073 | let err = '' | ||
2074 | if isdirectory(a:spec.dir) | ||
2075 | let result = s:lines(s:system('git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url', a:spec.dir)) | ||
2076 | let remote = result[-1] | ||
2077 | if v:shell_error | ||
2078 | let err = join([remote, 'PlugClean required.'], "\n") | ||
2079 | elseif !s:compare_git_uri(remote, a:spec.uri) | ||
2080 | let err = join(['Invalid URI: '.remote, | ||
2081 | \ 'Expected: '.a:spec.uri, | ||
2082 | \ 'PlugClean required.'], "\n") | ||
2083 | elseif a:check_branch && has_key(a:spec, 'commit') | ||
2084 | let result = s:lines(s:system('git rev-parse HEAD 2>&1', a:spec.dir)) | ||
2085 | let sha = result[-1] | ||
2086 | if v:shell_error | ||
2087 | let err = join(add(result, 'PlugClean required.'), "\n") | ||
2088 | elseif !s:hash_match(sha, a:spec.commit) | ||
2089 | let err = join([printf('Invalid HEAD (expected: %s, actual: %s)', | ||
2090 | \ a:spec.commit[:6], sha[:6]), | ||
2091 | \ 'PlugUpdate required.'], "\n") | ||
2092 | endif | ||
2093 | elseif a:check_branch | ||
2094 | let branch = result[0] | ||
2095 | " Check tag | ||
2096 | if has_key(a:spec, 'tag') | ||
2097 | let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir) | ||
2098 | if a:spec.tag !=# tag && a:spec.tag !~ '\*' | ||
2099 | let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.', | ||
2100 | \ (empty(tag) ? 'N/A' : tag), a:spec.tag) | ||
2101 | endif | ||
2102 | " Check branch | ||
2103 | elseif a:spec.branch !=# branch | ||
2104 | let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.', | ||
2105 | \ branch, a:spec.branch) | ||
2106 | endif | ||
2107 | if empty(err) | ||
2108 | let [ahead, behind] = split(s:lastline(s:system(printf( | ||
2109 | \ 'git rev-list --count --left-right HEAD...origin/%s', | ||
2110 | \ a:spec.branch), a:spec.dir)), '\t') | ||
2111 | if !v:shell_error && ahead | ||
2112 | if behind | ||
2113 | " Only mention PlugClean if diverged, otherwise it's likely to be | ||
2114 | " pushable (and probably not that messed up). | ||
2115 | let err = printf( | ||
2116 | \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n" | ||
2117 | \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', a:spec.branch, ahead, behind) | ||
2118 | else | ||
2119 | let err = printf("Ahead of origin/%s by %d commit(s).\n" | ||
2120 | \ .'Cannot update until local changes are pushed.', | ||
2121 | \ a:spec.branch, ahead) | ||
2122 | endif | ||
2123 | endif | ||
2124 | endif | ||
2125 | endif | ||
2126 | else | ||
2127 | let err = 'Not found' | ||
2128 | endif | ||
2129 | return [err, err =~# 'PlugClean'] | ||
2130 | endfunction | ||
2131 | |||
2132 | function! s:rm_rf(dir) | ||
2133 | if isdirectory(a:dir) | ||
2134 | call s:system((s:is_win ? 'rmdir /S /Q ' : 'rm -rf ') . plug#shellescape(a:dir)) | ||
2135 | endif | ||
2136 | endfunction | ||
2137 | |||
2138 | function! s:clean(force) | ||
2139 | call s:prepare() | ||
2140 | call append(0, 'Searching for invalid plugins in '.g:plug_home) | ||
2141 | call append(1, '') | ||
2142 | |||
2143 | " List of valid directories | ||
2144 | let dirs = [] | ||
2145 | let errs = {} | ||
2146 | let [cnt, total] = [0, len(g:plugs)] | ||
2147 | for [name, spec] in items(g:plugs) | ||
2148 | if !s:is_managed(name) | ||
2149 | call add(dirs, spec.dir) | ||
2150 | else | ||
2151 | let [err, clean] = s:git_validate(spec, 1) | ||
2152 | if clean | ||
2153 | let errs[spec.dir] = s:lines(err)[0] | ||
2154 | else | ||
2155 | call add(dirs, spec.dir) | ||
2156 | endif | ||
2157 | endif | ||
2158 | let cnt += 1 | ||
2159 | call s:progress_bar(2, repeat('=', cnt), total) | ||
2160 | normal! 2G | ||
2161 | redraw | ||
2162 | endfor | ||
2163 | |||
2164 | let allowed = {} | ||
2165 | for dir in dirs | ||
2166 | let allowed[s:dirpath(fnamemodify(dir, ':h:h'))] = 1 | ||
2167 | let allowed[dir] = 1 | ||
2168 | for child in s:glob_dir(dir) | ||
2169 | let allowed[child] = 1 | ||
2170 | endfor | ||
2171 | endfor | ||
2172 | |||
2173 | let todo = [] | ||
2174 | let found = sort(s:glob_dir(g:plug_home)) | ||
2175 | while !empty(found) | ||
2176 | let f = remove(found, 0) | ||
2177 | if !has_key(allowed, f) && isdirectory(f) | ||
2178 | call add(todo, f) | ||
2179 | call append(line('$'), '- ' . f) | ||
2180 | if has_key(errs, f) | ||
2181 | call append(line('$'), ' ' . errs[f]) | ||
2182 | endif | ||
2183 | let found = filter(found, 'stridx(v:val, f) != 0') | ||
2184 | end | ||
2185 | endwhile | ||
2186 | |||
2187 | 4 | ||
2188 | redraw | ||
2189 | if empty(todo) | ||
2190 | call append(line('$'), 'Already clean.') | ||
2191 | else | ||
2192 | let s:clean_count = 0 | ||
2193 | call append(3, ['Directories to delete:', '']) | ||
2194 | redraw! | ||
2195 | if a:force || s:ask_no_interrupt('Delete all directories?') | ||
2196 | call s:delete([6, line('$')], 1) | ||
2197 | else | ||
2198 | call setline(4, 'Cancelled.') | ||
2199 | nnoremap <silent> <buffer> d :set opfunc=<sid>delete_op<cr>g@ | ||
2200 | nmap <silent> <buffer> dd d_ | ||
2201 | xnoremap <silent> <buffer> d :<c-u>call <sid>delete_op(visualmode(), 1)<cr> | ||
2202 | echo 'Delete the lines (d{motion}) to delete the corresponding directories' | ||
2203 | endif | ||
2204 | endif | ||
2205 | 4 | ||
2206 | setlocal nomodifiable | ||
2207 | endfunction | ||
2208 | |||
2209 | function! s:delete_op(type, ...) | ||
2210 | call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0) | ||
2211 | endfunction | ||
2212 | |||
2213 | function! s:delete(range, force) | ||
2214 | let [l1, l2] = a:range | ||
2215 | let force = a:force | ||
2216 | while l1 <= l2 | ||
2217 | let line = getline(l1) | ||
2218 | if line =~ '^- ' && isdirectory(line[2:]) | ||
2219 | execute l1 | ||
2220 | redraw! | ||
2221 | let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1) | ||
2222 | let force = force || answer > 1 | ||
2223 | if answer | ||
2224 | call s:rm_rf(line[2:]) | ||
2225 | setlocal modifiable | ||
2226 | call setline(l1, '~'.line[1:]) | ||
2227 | let s:clean_count += 1 | ||
2228 | call setline(4, printf('Removed %d directories.', s:clean_count)) | ||
2229 | setlocal nomodifiable | ||
2230 | endif | ||
2231 | endif | ||
2232 | let l1 += 1 | ||
2233 | endwhile | ||
2234 | endfunction | ||
2235 | |||
2236 | function! s:upgrade() | ||
2237 | echo 'Downloading the latest version of vim-plug' | ||
2238 | redraw | ||
2239 | let tmp = tempname() | ||
2240 | let new = tmp . '/plug.vim' | ||
2241 | |||
2242 | try | ||
2243 | let out = s:system(printf('git clone --depth 1 %s %s', plug#shellescape(s:plug_src), plug#shellescape(tmp))) | ||
2244 | if v:shell_error | ||
2245 | return s:err('Error upgrading vim-plug: '. out) | ||
2246 | endif | ||
2247 | |||
2248 | if readfile(s:me) ==# readfile(new) | ||
2249 | echo 'vim-plug is already up-to-date' | ||
2250 | return 0 | ||
2251 | else | ||
2252 | call rename(s:me, s:me . '.old') | ||
2253 | call rename(new, s:me) | ||
2254 | unlet g:loaded_plug | ||
2255 | echo 'vim-plug has been upgraded' | ||
2256 | return 1 | ||
2257 | endif | ||
2258 | finally | ||
2259 | silent! call s:rm_rf(tmp) | ||
2260 | endtry | ||
2261 | endfunction | ||
2262 | |||
2263 | function! s:upgrade_specs() | ||
2264 | for spec in values(g:plugs) | ||
2265 | let spec.frozen = get(spec, 'frozen', 0) | ||
2266 | endfor | ||
2267 | endfunction | ||
2268 | |||
2269 | function! s:status() | ||
2270 | call s:prepare() | ||
2271 | call append(0, 'Checking plugins') | ||
2272 | call append(1, '') | ||
2273 | |||
2274 | let ecnt = 0 | ||
2275 | let unloaded = 0 | ||
2276 | let [cnt, total] = [0, len(g:plugs)] | ||
2277 | for [name, spec] in items(g:plugs) | ||
2278 | let is_dir = isdirectory(spec.dir) | ||
2279 | if has_key(spec, 'uri') | ||
2280 | if is_dir | ||
2281 | let [err, _] = s:git_validate(spec, 1) | ||
2282 | let [valid, msg] = [empty(err), empty(err) ? 'OK' : err] | ||
2283 | else | ||
2284 | let [valid, msg] = [0, 'Not found. Try PlugInstall.'] | ||
2285 | endif | ||
2286 | else | ||
2287 | if is_dir | ||
2288 | let [valid, msg] = [1, 'OK'] | ||
2289 | else | ||
2290 | let [valid, msg] = [0, 'Not found.'] | ||
2291 | endif | ||
2292 | endif | ||
2293 | let cnt += 1 | ||
2294 | let ecnt += !valid | ||
2295 | " `s:loaded` entry can be missing if PlugUpgraded | ||
2296 | if is_dir && get(s:loaded, name, -1) == 0 | ||
2297 | let unloaded = 1 | ||
2298 | let msg .= ' (not loaded)' | ||
2299 | endif | ||
2300 | call s:progress_bar(2, repeat('=', cnt), total) | ||
2301 | call append(3, s:format_message(valid ? '-' : 'x', name, msg)) | ||
2302 | normal! 2G | ||
2303 | redraw | ||
2304 | endfor | ||
2305 | call setline(1, 'Finished. '.ecnt.' error(s).') | ||
2306 | normal! gg | ||
2307 | setlocal nomodifiable | ||
2308 | if unloaded | ||
2309 | echo "Press 'L' on each line to load plugin, or 'U' to update" | ||
2310 | nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr> | ||
2311 | xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr> | ||
2312 | end | ||
2313 | endfunction | ||
2314 | |||
2315 | function! s:extract_name(str, prefix, suffix) | ||
2316 | return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$') | ||
2317 | endfunction | ||
2318 | |||
2319 | function! s:status_load(lnum) | ||
2320 | let line = getline(a:lnum) | ||
2321 | let name = s:extract_name(line, '-', '(not loaded)') | ||
2322 | if !empty(name) | ||
2323 | call plug#load(name) | ||
2324 | setlocal modifiable | ||
2325 | call setline(a:lnum, substitute(line, ' (not loaded)$', '', '')) | ||
2326 | setlocal nomodifiable | ||
2327 | endif | ||
2328 | endfunction | ||
2329 | |||
2330 | function! s:status_update() range | ||
2331 | let lines = getline(a:firstline, a:lastline) | ||
2332 | let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)') | ||
2333 | if !empty(names) | ||
2334 | echo | ||
2335 | execute 'PlugUpdate' join(names) | ||
2336 | endif | ||
2337 | endfunction | ||
2338 | |||
2339 | function! s:is_preview_window_open() | ||
2340 | silent! wincmd P | ||
2341 | if &previewwindow | ||
2342 | wincmd p | ||
2343 | return 1 | ||
2344 | endif | ||
2345 | endfunction | ||
2346 | |||
2347 | function! s:find_name(lnum) | ||
2348 | for lnum in reverse(range(1, a:lnum)) | ||
2349 | let line = getline(lnum) | ||
2350 | if empty(line) | ||
2351 | return '' | ||
2352 | endif | ||
2353 | let name = s:extract_name(line, '-', '') | ||
2354 | if !empty(name) | ||
2355 | return name | ||
2356 | endif | ||
2357 | endfor | ||
2358 | return '' | ||
2359 | endfunction | ||
2360 | |||
2361 | function! s:preview_commit() | ||
2362 | if b:plug_preview < 0 | ||
2363 | let b:plug_preview = !s:is_preview_window_open() | ||
2364 | endif | ||
2365 | |||
2366 | let sha = matchstr(getline('.'), '^ \X*\zs[0-9a-f]\{7,9}') | ||
2367 | if empty(sha) | ||
2368 | return | ||
2369 | endif | ||
2370 | |||
2371 | let name = s:find_name(line('.')) | ||
2372 | if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir) | ||
2373 | return | ||
2374 | endif | ||
2375 | |||
2376 | if exists('g:plug_pwindow') && !s:is_preview_window_open() | ||
2377 | execute g:plug_pwindow | ||
2378 | execute 'e' sha | ||
2379 | else | ||
2380 | execute 'pedit' sha | ||
2381 | wincmd P | ||
2382 | endif | ||
2383 | setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable | ||
2384 | try | ||
2385 | let [sh, shellcmdflag, shrd] = s:chsh(1) | ||
2386 | let cmd = 'cd '.plug#shellescape(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha | ||
2387 | if s:is_win | ||
2388 | let [batchfile, cmd] = s:batchfile(cmd) | ||
2389 | endif | ||
2390 | execute 'silent %!' cmd | ||
2391 | finally | ||
2392 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] | ||
2393 | if s:is_win | ||
2394 | call delete(batchfile) | ||
2395 | endif | ||
2396 | endtry | ||
2397 | setlocal nomodifiable | ||
2398 | nnoremap <silent> <buffer> q :q<cr> | ||
2399 | wincmd p | ||
2400 | endfunction | ||
2401 | |||
2402 | function! s:section(flags) | ||
2403 | call search('\(^[x-] \)\@<=[^:]\+:', a:flags) | ||
2404 | endfunction | ||
2405 | |||
2406 | function! s:format_git_log(line) | ||
2407 | let indent = ' ' | ||
2408 | let tokens = split(a:line, nr2char(1)) | ||
2409 | if len(tokens) != 5 | ||
2410 | return indent.substitute(a:line, '\s*$', '', '') | ||
2411 | endif | ||
2412 | let [graph, sha, refs, subject, date] = tokens | ||
2413 | let tag = matchstr(refs, 'tag: [^,)]\+') | ||
2414 | let tag = empty(tag) ? ' ' : ' ('.tag.') ' | ||
2415 | return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date) | ||
2416 | endfunction | ||
2417 | |||
2418 | function! s:append_ul(lnum, text) | ||
2419 | call append(a:lnum, ['', a:text, repeat('-', len(a:text))]) | ||
2420 | endfunction | ||
2421 | |||
2422 | function! s:diff() | ||
2423 | call s:prepare() | ||
2424 | call append(0, ['Collecting changes ...', '']) | ||
2425 | let cnts = [0, 0] | ||
2426 | let bar = '' | ||
2427 | let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)') | ||
2428 | call s:progress_bar(2, bar, len(total)) | ||
2429 | for origin in [1, 0] | ||
2430 | let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))')))) | ||
2431 | if empty(plugs) | ||
2432 | continue | ||
2433 | endif | ||
2434 | call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:') | ||
2435 | for [k, v] in plugs | ||
2436 | let range = origin ? '..origin/'.v.branch : 'HEAD@{1}..' | ||
2437 | let cmd = 'git log --graph --color=never '.join(map(['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range], 'plug#shellescape(v:val)')) | ||
2438 | if has_key(v, 'rtp') | ||
2439 | let cmd .= ' -- '.plug#shellescape(v.rtp) | ||
2440 | endif | ||
2441 | let diff = s:system_chomp(cmd, v.dir) | ||
2442 | if !empty(diff) | ||
2443 | let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : '' | ||
2444 | call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)'))) | ||
2445 | let cnts[origin] += 1 | ||
2446 | endif | ||
2447 | let bar .= '=' | ||
2448 | call s:progress_bar(2, bar, len(total)) | ||
2449 | normal! 2G | ||
2450 | redraw | ||
2451 | endfor | ||
2452 | if !cnts[origin] | ||
2453 | call append(5, ['', 'N/A']) | ||
2454 | endif | ||
2455 | endfor | ||
2456 | call setline(1, printf('%d plugin(s) updated.', cnts[0]) | ||
2457 | \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : '')) | ||
2458 | |||
2459 | if cnts[0] || cnts[1] | ||
2460 | nnoremap <silent> <buffer> <plug>(plug-preview) :silent! call <SID>preview_commit()<cr> | ||
2461 | if empty(maparg("\<cr>", 'n')) | ||
2462 | nmap <buffer> <cr> <plug>(plug-preview) | ||
2463 | endif | ||
2464 | if empty(maparg('o', 'n')) | ||
2465 | nmap <buffer> o <plug>(plug-preview) | ||
2466 | endif | ||
2467 | endif | ||
2468 | if cnts[0] | ||
2469 | nnoremap <silent> <buffer> X :call <SID>revert()<cr> | ||
2470 | echo "Press 'X' on each block to revert the update" | ||
2471 | endif | ||
2472 | normal! gg | ||
2473 | setlocal nomodifiable | ||
2474 | endfunction | ||
2475 | |||
2476 | function! s:revert() | ||
2477 | if search('^Pending updates', 'bnW') | ||
2478 | return | ||
2479 | endif | ||
2480 | |||
2481 | let name = s:find_name(line('.')) | ||
2482 | if empty(name) || !has_key(g:plugs, name) || | ||
2483 | \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y' | ||
2484 | return | ||
2485 | endif | ||
2486 | |||
2487 | call s:system('git reset --hard HEAD@{1} && git checkout '.s:esc(g:plugs[name].branch).' --', g:plugs[name].dir) | ||
2488 | setlocal modifiable | ||
2489 | normal! "_dap | ||
2490 | setlocal nomodifiable | ||
2491 | echo 'Reverted' | ||
2492 | endfunction | ||
2493 | |||
2494 | function! s:snapshot(force, ...) abort | ||
2495 | call s:prepare() | ||
2496 | setf vim | ||
2497 | call append(0, ['" Generated by vim-plug', | ||
2498 | \ '" '.strftime("%c"), | ||
2499 | \ '" :source this file in vim to restore the snapshot', | ||
2500 | \ '" or execute: vim -S snapshot.vim', | ||
2501 | \ '', '', 'PlugUpdate!']) | ||
2502 | 1 | ||
2503 | let anchor = line('$') - 3 | ||
2504 | let names = sort(keys(filter(copy(g:plugs), | ||
2505 | \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)'))) | ||
2506 | for name in reverse(names) | ||
2507 | let sha = s:system_chomp('git rev-parse --short HEAD', g:plugs[name].dir) | ||
2508 | if !empty(sha) | ||
2509 | call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha)) | ||
2510 | redraw | ||
2511 | endif | ||
2512 | endfor | ||
2513 | |||
2514 | if a:0 > 0 | ||
2515 | let fn = expand(a:1) | ||
2516 | if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?')) | ||
2517 | return | ||
2518 | endif | ||
2519 | call writefile(getline(1, '$'), fn) | ||
2520 | echo 'Saved as '.a:1 | ||
2521 | silent execute 'e' s:esc(fn) | ||
2522 | setf vim | ||
2523 | endif | ||
2524 | endfunction | ||
2525 | |||
2526 | function! s:split_rtp() | ||
2527 | return split(&rtp, '\\\@<!,') | ||
2528 | endfunction | ||
2529 | |||
2530 | let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, '')) | ||
2531 | let s:last_rtp = s:escrtp(get(s:split_rtp(), -1, '')) | ||
2532 | |||
2533 | if exists('g:plugs') | ||
2534 | let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs)) | ||
2535 | call s:upgrade_specs() | ||
2536 | call s:define_commands() | ||
2537 | endif | ||
2538 | |||
2539 | let &cpo = s:cpo_save | ||
2540 | unlet s:cpo_save | ||
diff --git a/nvim/.config/nvim/coc-settings.json b/nvim/.config/nvim/coc-settings.json new file mode 100644 index 0000000..872ca3d --- /dev/null +++ b/nvim/.config/nvim/coc-settings.json | |||
@@ -0,0 +1,54 @@ | |||
1 | { | ||
2 | "suggest.timeout": 500, | ||
3 | "coc.source.vimtex.enable": true, | ||
4 | "coc.preferences.formatOnSaveFiletypes": [ | ||
5 | "dart", | ||
6 | "python" | ||
7 | ], | ||
8 | "languageserver": { | ||
9 | "bash": { | ||
10 | "command": "bash-language-server", | ||
11 | "args": ["start"], | ||
12 | "filetypes": ["sh"], | ||
13 | "ignoredRootPaths": ["~"] | ||
14 | }, | ||
15 | "ccls": { | ||
16 | "command": "ccls", | ||
17 | "filetypes": ["c", "cpp", "objc", "objcpp"], | ||
18 | "rootPatterns": [".ccls", "compile_commands.json", ".vim/", ".git/", ".hg/"], | ||
19 | "initializationOptions": { | ||
20 | "cache": { | ||
21 | "directory": "/tmp/ccls" | ||
22 | }, | ||
23 | "cformatpath": "/bin/clang-format" | ||
24 | } | ||
25 | }, | ||
26 | "haskell": { | ||
27 | "command": "hie-wrapper", | ||
28 | "args": ["--lsp"], | ||
29 | "rootPatterns": [ | ||
30 | "stack.yaml", | ||
31 | "cabal.config", | ||
32 | "package.yaml" | ||
33 | ], | ||
34 | "filetypes": [ | ||
35 | "hs", | ||
36 | "lhs", | ||
37 | "haskell" | ||
38 | ], | ||
39 | "initializationOptions": { | ||
40 | "languageServerHaskell": { | ||
41 | "hlintOn": true | ||
42 | } | ||
43 | } | ||
44 | } | ||
45 | }, | ||
46 | "diagnostic.errorSign": "×", | ||
47 | "diagnostic.warningSign": "!", | ||
48 | "python.formatting.provider": "black", | ||
49 | "python.jediEnabled": true, | ||
50 | "rust-analyzer.serverPath": "~/.cargo/bin/rust-analyzer", | ||
51 | "rust-analyzer.inlayHints.chainingHints": true, | ||
52 | "rust-analyzer.procMacro.enable": true, | ||
53 | "rust-analyzer.lruCapacity": 12 | ||
54 | } | ||
diff --git a/nvim/.config/nvim/ftplugin/asm.vim b/nvim/.config/nvim/ftplugin/asm.vim new file mode 100644 index 0000000..dde370b --- /dev/null +++ b/nvim/.config/nvim/ftplugin/asm.vim | |||
@@ -0,0 +1 @@ | |||
syntax off | |||
diff --git a/nvim/.config/nvim/ftplugin/javascript.vim b/nvim/.config/nvim/ftplugin/javascript.vim new file mode 100644 index 0000000..454c153 --- /dev/null +++ b/nvim/.config/nvim/ftplugin/javascript.vim | |||
@@ -0,0 +1,8 @@ | |||
1 | setlocal tabstop=2 | ||
2 | setlocal shiftwidth=2 | ||
3 | setlocal softtabstop=2 | ||
4 | setlocal formatoptions=croq | ||
5 | setlocal expandtab | ||
6 | setlocal autoindent | ||
7 | setlocal smarttab | ||
8 | |||
diff --git a/nvim/.config/nvim/ftplugin/python.vim b/nvim/.config/nvim/ftplugin/python.vim new file mode 100644 index 0000000..2a918fb --- /dev/null +++ b/nvim/.config/nvim/ftplugin/python.vim | |||
@@ -0,0 +1,7 @@ | |||
1 | setlocal tabstop=4 | ||
2 | setlocal softtabstop=4 | ||
3 | setlocal shiftwidth=4 | ||
4 | setlocal expandtab | ||
5 | setlocal autoindent | ||
6 | setlocal smarttab | ||
7 | setlocal formatoptions=croql | ||
diff --git a/nvim/.config/nvim/ftplugin/rust.vim b/nvim/.config/nvim/ftplugin/rust.vim new file mode 100644 index 0000000..cfd90ec --- /dev/null +++ b/nvim/.config/nvim/ftplugin/rust.vim | |||
@@ -0,0 +1 @@ | |||
setlocal ts=4 sts=4 sw=4 expandtab | |||
diff --git a/nvim/.config/nvim/ftplugin/scheme.vim b/nvim/.config/nvim/ftplugin/scheme.vim new file mode 100644 index 0000000..ac0ba6e --- /dev/null +++ b/nvim/.config/nvim/ftplugin/scheme.vim | |||
@@ -0,0 +1,10 @@ | |||
1 | setlocal tabstop=2 | ||
2 | setlocal softtabstop=2 | ||
3 | setlocal shiftwidth=2 | ||
4 | setlocal expandtab | ||
5 | setlocal autoindent | ||
6 | setlocal smarttab | ||
7 | setlocal formatoptions=croql | ||
8 | |||
9 | CocDisable | ||
10 | let b:AutoPairs = {"(": ")", "[": "]", "{": "}", '"': '"' } | ||
diff --git a/nvim/.config/nvim/ftplugin/tex.vim b/nvim/.config/nvim/ftplugin/tex.vim new file mode 100644 index 0000000..2b63637 --- /dev/null +++ b/nvim/.config/nvim/ftplugin/tex.vim | |||
@@ -0,0 +1,3 @@ | |||
1 | setlocal wrap | ||
2 | nnoremap j gj | ||
3 | nnoremap k gk | ||
diff --git a/nvim/.config/nvim/ftplugin/typescript.vim b/nvim/.config/nvim/ftplugin/typescript.vim new file mode 100644 index 0000000..c6132bb --- /dev/null +++ b/nvim/.config/nvim/ftplugin/typescript.vim | |||
@@ -0,0 +1,7 @@ | |||
1 | setlocal tabstop=2 | ||
2 | setlocal shiftwidth=2 | ||
3 | setlocal softtabstop=2 | ||
4 | setlocal formatoptions=croq | ||
5 | setlocal expandtab | ||
6 | setlocal autoindent | ||
7 | setlocal smarttab | ||
diff --git a/nvim/.config/nvim/init.vim b/nvim/.config/nvim/init.vim new file mode 100644 index 0000000..3de2adb --- /dev/null +++ b/nvim/.config/nvim/init.vim | |||
@@ -0,0 +1,185 @@ | |||
1 | let &t_ZM = "\e[3m" | ||
2 | |||
3 | " vim-plugs | ||
4 | call plug#begin('~/.local/share/nvim/plugged') | ||
5 | |||
6 | Plug 'airblade/vim-gitgutter' | ||
7 | Plug 'andymass/vim-matchup' | ||
8 | Plug 'godlygeek/tabular' | ||
9 | Plug 'jiangmiao/auto-pairs' | ||
10 | Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' } | ||
11 | Plug 'junegunn/fzf.vim' | ||
12 | Plug 'mattn/emmet-vim', {'for': ['javascript.jsx', 'html', 'css']} | ||
13 | Plug 'neoclide/coc.nvim', {'do': { -> coc#util#install()}, 'branch': 'release'} | ||
14 | Plug 'wellle/targets.vim' | ||
15 | Plug 'editorconfig/editorconfig-vim' | ||
16 | |||
17 | " tpope | ||
18 | Plug 'tpope/vim-repeat' | ||
19 | Plug 'tpope/vim-surround' | ||
20 | Plug 'tpope/vim-unimpaired' | ||
21 | Plug 'tpope/vim-fugitive' | ||
22 | |||
23 | " syntax and friends | ||
24 | Plug 'leafgarland/typescript-vim', {'for' : 'typescript'} | ||
25 | Plug 'mxw/vim-jsx', {'for' : 'javascript.jsx'} | ||
26 | Plug 'pangloss/vim-javascript', {'for' : ['javascript.jsx', 'javascript']} | ||
27 | Plug 'rust-lang/rust.vim', {'for': 'rust'} | ||
28 | Plug 'lervag/vimtex', {'for': 'tex'} | ||
29 | Plug 'neovimhaskell/haskell-vim', {'for': 'haskell'} | ||
30 | |||
31 | " colorschemes | ||
32 | Plug 'nerdypepper/agila.vim' | ||
33 | Plug 'nerdypepper/chestnut.vim' | ||
34 | Plug 'nerdypepper/vim-colors-plain', { 'branch': 'duotone' } | ||
35 | |||
36 | call plug#end() | ||
37 | |||
38 | " augroups | ||
39 | |||
40 | augroup plaintext | ||
41 | autocmd! | ||
42 | autocmd FileType text,markdown setlocal ts=2 sts=2 sw=2 expandtab textwidth=60 | ||
43 | augroup END | ||
44 | |||
45 | augroup webdev | ||
46 | autocmd! | ||
47 | autocmd FileType less,css,html,js?,ts? setlocal ts=2 sts=2 sw=2 expandtab | ||
48 | autocmd FileType less,css,html nnoremap <Leader>s viB:sort<cr> | ||
49 | augroup END | ||
50 | |||
51 | augroup restorecursor | ||
52 | autocmd BufReadPost * | ||
53 | \ if line("'\"") > 1 && line("'\"") <= line("$") | | ||
54 | \ execute "normal! g`\"" | | ||
55 | \ endif | ||
56 | augroup END | ||
57 | |||
58 | " general settings | ||
59 | set nobackup | ||
60 | set nowritebackup | ||
61 | set noswapfile " get rid of swapfiles everywhere | ||
62 | set dir=/tmp | ||
63 | |||
64 | syntax on | ||
65 | |||
66 | set omnifunc=syntaxcomplete#Complete | ||
67 | set completefunc=LanguageClient#complete | ||
68 | set list | ||
69 | filetype off | ||
70 | filetype plugin indent on | ||
71 | set laststatus=2 | ||
72 | set nowrap | ||
73 | set noshowmode | ||
74 | set listchars=tab:┊\ ,nbsp:␣,trail:·,extends:>,precedes:< | ||
75 | set fillchars=vert:\│ | ||
76 | set ignorecase | ||
77 | set smartcase | ||
78 | set sidescroll=40 | ||
79 | set incsearch | ||
80 | set hlsearch | ||
81 | set undofile | ||
82 | set undodir=~/tmp | ||
83 | set path+=** | ||
84 | set backspace=indent,eol,start | ||
85 | set hidden | ||
86 | set wildmenu | ||
87 | set foldmethod=manual | ||
88 | set complete=.,w,b,i,u,t, | ||
89 | set background=dark | ||
90 | set mouse=a | ||
91 | set conceallevel=0 | ||
92 | set nocursorline | ||
93 | set nonumber | ||
94 | set grepprg=rg\ --vimgrep\ --no-heading | ||
95 | set grepformat=%f:%l:%c:%m,%f:%l:%m | ||
96 | set cmdheight=2 | ||
97 | set shortmess+=c | ||
98 | set updatetime=300 | ||
99 | set signcolumn=yes | ||
100 | set inccommand=split | ||
101 | |||
102 | let g:netrw_browsex_viewer= "xdg-open" | ||
103 | |||
104 | colorscheme plain | ||
105 | |||
106 | set shiftwidth=4 " indent = 4 spaces | ||
107 | set expandtab | ||
108 | set tabstop=4 " tab = 4 spaces | ||
109 | set softtabstop=4 " backspace through spaces | ||
110 | |||
111 | " Functions | ||
112 | function! GetTabber() " a lil function that integrates well with Tabular.vim | ||
113 | let c = nr2char(getchar()) | ||
114 | :execute 'Tabularize /' . c | ||
115 | endfunction | ||
116 | |||
117 | " Ugh | ||
118 | :command! WQ wq | ||
119 | :command! Wq wq | ||
120 | :command! Wqa wqa | ||
121 | :command! W w | ||
122 | :command! Q q | ||
123 | |||
124 | " abbreviations | ||
125 | abclear | ||
126 | iab #i #include | ||
127 | iab #d #define | ||
128 | cab dst put =strftime('%d %a, %b %Y')<cr> | ||
129 | cab vg vimgrep | ||
130 | |||
131 | |||
132 | " plugin settings | ||
133 | |||
134 | " emmet | ||
135 | let g:user_emmet_mode='a' | ||
136 | let g:user_emmet_leader_key='<C-X>' | ||
137 | |||
138 | " gitgutter | ||
139 | let g:gitgutter_override_sign_column_highlight = 0 | ||
140 | let g:gitgutter_sign_added = '+' " '┃' | ||
141 | let g:gitgutter_sign_modified = '~' " '┃' | ||
142 | let g:gitgutter_sign_removed = '-' " '┃' | ||
143 | let g:gitgutter_sign_removed_first_line = '-' " '┃' | ||
144 | let g:gitgutter_sign_modified_removed = '~' " '┃' | ||
145 | |||
146 | highlight GitGutterAdd ctermfg=8 | ||
147 | highlight GitGutterChange ctermfg=8 | ||
148 | highlight GitGutterDelete ctermfg=8 | ||
149 | |||
150 | " rust.vim | ||
151 | let g:rustfmt_autosave = 1 | ||
152 | |||
153 | " fzf colors | ||
154 | let g:fzf_colors = | ||
155 | \ { 'fg': ['fg', 'Normal'], | ||
156 | \ 'bg': ['bg', 'Normal'], | ||
157 | \ 'hl': ['fg', 'Comment'], | ||
158 | \ 'fg+': ['fg', 'CursorLine', 'CursorColumn', 'Normal'], | ||
159 | \ 'bg+': ['bg', 'CursorLine', 'CursorColumn'], | ||
160 | \ 'hl+': ['fg', 'Statement'], | ||
161 | \ 'info': ['fg', 'PreProc'], | ||
162 | \ 'border': ['fg', 'Ignore'], | ||
163 | \ 'prompt': ['fg', 'Conditional'], | ||
164 | \ 'pointer': ['fg', 'Exception'], | ||
165 | \ 'marker': ['fg', 'Keyword'], | ||
166 | \ 'spinner': ['fg', 'Label'], | ||
167 | \ 'header': ['fg', 'Comment'] } | ||
168 | |||
169 | " indentLine | ||
170 | let g:indentLine_setColors = 0 | ||
171 | let g:indentLine_char = '┆' | ||
172 | |||
173 | let g:latex_view_general_viewer = 'zathura' | ||
174 | let g:vimtex_view_method = "zathura" | ||
175 | |||
176 | " man pages | ||
177 | let g:ft_man_open_mode = 'tab' | ||
178 | |||
179 | " vim-matchup | ||
180 | let g:matchup_matchparen_deferred = 1 | ||
181 | let g:matchup_matchparen_hi_surround_always = 1 | ||
182 | |||
183 | " coc-nvim | ||
184 | hi CocHintSign ctermfg=7 | ||
185 | let g:python3_host_prog="/usr/bin/python3" | ||
diff --git a/nvim/.config/nvim/plugin/help.vim b/nvim/.config/nvim/plugin/help.vim new file mode 100644 index 0000000..9e1c998 --- /dev/null +++ b/nvim/.config/nvim/plugin/help.vim | |||
@@ -0,0 +1,16 @@ | |||
1 | " Only apply to .txt files... | ||
2 | augroup HelpInTabs | ||
3 | autocmd! | ||
4 | autocmd BufEnter *.txt call HelpInNewTab() | ||
5 | augroup END | ||
6 | |||
7 | " Only apply to help files... | ||
8 | function! HelpInNewTab () | ||
9 | if &buftype == 'help' && g:help_in_tabs | ||
10 | "Convert the help window to a tab... | ||
11 | execute "normal \<C-W>T" | ||
12 | endif | ||
13 | endfunction | ||
14 | |||
15 | let g:help_in_tabs = 1 | ||
16 | |||
diff --git a/nvim/.config/nvim/plugin/ignores.vim b/nvim/.config/nvim/plugin/ignores.vim new file mode 100644 index 0000000..3ab37f0 --- /dev/null +++ b/nvim/.config/nvim/plugin/ignores.vim | |||
@@ -0,0 +1,11 @@ | |||
1 | set wildignore+=.git,.hg,.svn | ||
2 | set wildignore+=*.aux,*.out,*.toc | ||
3 | set wildignore+=*.o,*.obj,*.exe,*.dll,*.manifest,*.rbc,*.class | ||
4 | set wildignore+=*.ai,*.bmp,*.gif,*.ico,*.jpg,*.jpeg,*.png,*.psd,*.webp | ||
5 | set wildignore+=*.avi,*.divx,*.mp4,*.webm,*.mov,*.m2ts,*.mkv,*.vob,*.mpg,*.mpeg | ||
6 | set wildignore+=*.mp3,*.oga,*.ogg,*.wav,*.flac | ||
7 | set wildignore+=*.eot,*.otf,*.ttf,*.woff | ||
8 | set wildignore+=*.doc,*.pdf,*.cbr,*.cbz | ||
9 | set wildignore+=*.zip,*.tar.gz,*.tar.bz2,*.rar,*.tar.xz,*.kgb | ||
10 | set wildignore+=*.swp,.lock,.DS_Store,._* | ||
11 | |||
diff --git a/nvim/.config/nvim/plugin/maps.vim b/nvim/.config/nvim/plugin/maps.vim new file mode 100644 index 0000000..55990d2 --- /dev/null +++ b/nvim/.config/nvim/plugin/maps.vim | |||
@@ -0,0 +1,78 @@ | |||
1 | mapclear | ||
2 | |||
3 | let mapleader=' ' | ||
4 | |||
5 | " clipboard | ||
6 | map <leader>cc :w !xclip -sel c<CR> | ||
7 | |||
8 | " normal | ||
9 | nnoremap <Leader>o : only<cr> | ||
10 | " nnoremap <Leader>l : Lines<cr> | ||
11 | nnoremap <Leader>b : Buffers<cr> | ||
12 | nnoremap <Leader>n : bnext<cr> | ||
13 | nnoremap <Leader>p : bprev<cr> | ||
14 | nnoremap <Leader>z : FZF<cr> | ||
15 | nnoremap <Leader>l : Lines<cr> | ||
16 | nnoremap <Leader>w : MtaJumpToOtherTag<cr> | ||
17 | nnoremap <Leader>t : call GetTabber()<cr> | ||
18 | nnoremap <Leader><ESC> : nohlsearch<cr> | ||
19 | nnoremap <C-l> :nohlsearch<cr>:diffupdate<cr>:syntax sync fromstart<cr><c-l> | ||
20 | nnoremap H H:exec 'norm! '. &scrolloff . 'k'<cr> | ||
21 | nnoremap L L:exec 'norm! '. &scrolloff . 'j'<cr> | ||
22 | nnoremap <expr> gb '`[' . strpart(getregtype(), 0, 1) . '`]' | ||
23 | |||
24 | |||
25 | nnoremap <F10> :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<' | ||
26 | \ . synIDattr(synID(line("."),col("."),0),"name") . "> lo<" | ||
27 | \ . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"<CR> | ||
28 | |||
29 | cmap w!! %!sudo tee > /dev/null % | ||
30 | |||
31 | " visual | ||
32 | vnoremap > >gv | ||
33 | vnoremap < <gv | ||
34 | |||
35 | " operator-pending | ||
36 | onoremap ax a` | ||
37 | onoremap ix i` | ||
38 | |||
39 | " visual block | ||
40 | xnoremap + g<C-a> | ||
41 | xnoremap - g<C-x> | ||
42 | |||
43 | " COC keymaps | ||
44 | inoremap <silent><expr> <TAB> | ||
45 | \ pumvisible() ? "\<C-n>" : | ||
46 | \ <SID>check_back_space() ? "\<TAB>" : | ||
47 | \ coc#refresh() | ||
48 | inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>" | ||
49 | |||
50 | function! s:check_back_space() abort | ||
51 | let col = col('.') - 1 | ||
52 | return !col || getline('.')[col - 1] =~# '\s' | ||
53 | endfunction | ||
54 | |||
55 | inoremap <silent><expr> <c-space> coc#refresh() | ||
56 | |||
57 | inoremap <expr> <cr> pumvisible() ? "\<C-y>" : "\<C-g>u\<CR>" | ||
58 | |||
59 | nmap <silent> [g <Plug>(coc-diagnostic-prev) | ||
60 | nmap <silent> ]g <Plug>(coc-diagnostic-next) | ||
61 | nmap <silent> gd <Plug>(coc-definition) | ||
62 | nmap <silent> gy <Plug>(coc-type-definition) | ||
63 | nmap <silent> gr <Plug>(coc-references) | ||
64 | |||
65 | nnoremap <silent> K :call <SID>show_documentation()<CR> | ||
66 | |||
67 | function! s:show_documentation() | ||
68 | if (index(['vim','help'], &filetype) >= 0) | ||
69 | execute 'h '.expand('<cword>') | ||
70 | else | ||
71 | call CocAction('doHover') | ||
72 | endif | ||
73 | endfunction | ||
74 | |||
75 | nmap <leader>rn <Plug>(coc-rename) | ||
76 | |||
77 | xmap <leader>f <Plug>(coc-format-selected) | ||
78 | nmap <leader>f <Plug>(coc-format-selected) | ||
diff --git a/nvim/.config/nvim/plugin/statusline.vim b/nvim/.config/nvim/plugin/statusline.vim new file mode 100644 index 0000000..a25fb6d --- /dev/null +++ b/nvim/.config/nvim/plugin/statusline.vim | |||
@@ -0,0 +1,136 @@ | |||
1 | scriptencoding utf-8 | ||
2 | |||
3 | " statusline | ||
4 | |||
5 | let g:currentmode={ | ||
6 | \ 'n' : 'NORMAL ', | ||
7 | \ 'no' : 'N·OPERATOR PENDING ', | ||
8 | \ 'v' : 'VISUAL ', | ||
9 | \ 'V' : 'V·LINE ', | ||
10 | \ '' : 'V·BLOCK ', | ||
11 | \ 's' : 'SELECT ', | ||
12 | \ 'S' : 'S·LINE ', | ||
13 | \ '' : 'S·BLOCK ', | ||
14 | \ 'i' : 'INSERT ', | ||
15 | \ 'R' : 'REPLACE ', | ||
16 | \ 'Rv' : 'V·REPLACE ', | ||
17 | \ 'c' : 'COMMAND ', | ||
18 | \ 'cv' : 'VIM EX ', | ||
19 | \ 'ce' : 'EX ', | ||
20 | \ 'r' : 'PROMPT ', | ||
21 | \ 'rm' : 'MORE ', | ||
22 | \ 'r?' : 'CONFIRM ', | ||
23 | \ '!' : 'SHELL ', | ||
24 | \ 't' : 'TERMINAL '} | ||
25 | |||
26 | hi PrimaryBlock ctermfg=00 ctermbg=6 | ||
27 | hi SecondaryBlock ctermfg=07 ctermbg=10 | ||
28 | hi Blanks ctermfg=11 ctermbg=0 | ||
29 | |||
30 | hi User1 ctermfg=01 ctermbg=0 | ||
31 | hi User2 ctermfg=02 ctermbg=0 | ||
32 | hi User3 ctermfg=03 ctermbg=0 | ||
33 | hi User4 ctermfg=04 ctermbg=0 | ||
34 | hi User5 ctermfg=05 ctermbg=0 | ||
35 | hi User6 ctermfg=06 ctermbg=0 | ||
36 | hi User7 ctermfg=07 ctermbg=0 | ||
37 | hi User8 ctermfg=08 ctermbg=0 | ||
38 | hi User9 ctermfg=09 ctermbg=0 | ||
39 | |||
40 | highlight EndOfBuffer ctermfg=black ctermbg=black | ||
41 | |||
42 | function! GitBranch() | ||
43 | return system("git rev-parse --abbrev-ref HEAD 2>/dev/null | tr -d '\n'") | ||
44 | endfunction | ||
45 | |||
46 | function! StatuslineGit() | ||
47 | let l:branchname = GitBranch() | ||
48 | return strlen(l:branchname) > 0?' '.l:branchname.' ':'' | ||
49 | endfunction | ||
50 | |||
51 | function! ReadOnly() abort | ||
52 | if !&modifiable && &readonly | ||
53 | return ' RO' | ||
54 | elseif &modifiable && &readonly | ||
55 | return 'RO' | ||
56 | elseif !&modifiable && !&readonly | ||
57 | return '' | ||
58 | else | ||
59 | return '' | ||
60 | endif | ||
61 | endfunction | ||
62 | |||
63 | function! Filepath() abort | ||
64 | let l:basename = expand('%:h') | ||
65 | let l:filename = expand('%:t') | ||
66 | let l:extension = expand('%:e') | ||
67 | let l:prefix = (l:basename ==# '' || l:basename ==# '.') ? | ||
68 | \ '' : substitute(l:basename . '/', '\C^' . $HOME, '~', '') | ||
69 | |||
70 | if empty(l:prefix) && empty(l:filename) | ||
71 | return printf('%%8*%%f%%*%s %%m%%*', '%8*') | ||
72 | elseif empty(l:prefix) | ||
73 | return printf('%%8*%%f%%*%s %%m%%*', '%6*') | ||
74 | else | ||
75 | return printf('%%8*%s%%*%s%s%%*', l:prefix, &modified ? '%6*' : '%8*', l:filename) | ||
76 | endif | ||
77 | endfunction | ||
78 | |||
79 | function! LinterStatus() abort | ||
80 | let info = get(b:, 'coc_diagnostic_info', {}) | ||
81 | if empty(info) | return '' | endif | ||
82 | let msgs = [] | ||
83 | if get(info, 'error', 0) | ||
84 | call add(msgs, printf('%%5*%s×%%*', info['error'])) | ||
85 | endif | ||
86 | if get(info, 'warning', 0) | ||
87 | call add(msgs, printf('%%3*%s!%%*', info['warning'])) | ||
88 | endif | ||
89 | return join(msgs, ' ') | ||
90 | endfunction | ||
91 | |||
92 | function! StatusLine(mode) abort | ||
93 | let l:line='' | ||
94 | |||
95 | " help or man pages | ||
96 | if &filetype ==# 'help' || &filetype ==# 'man' | ||
97 | let l:line.=' %#StatusLineNC# ['. &filetype .'] %f ' | ||
98 | return l:line | ||
99 | endif | ||
100 | |||
101 | " active | ||
102 | if a:mode ==# 'active' | ||
103 | let l:line.='%7*%{StatuslineGit()}' | ||
104 | let l:line.='%<' | ||
105 | let l:line.=Filepath() | ||
106 | |||
107 | let l:line.='%5*' | ||
108 | let l:line.=' %{ReadOnly()} %w%*' | ||
109 | let l:line.='%9* %=%*' | ||
110 | |||
111 | let l:line.='%7* %l,%c %*' | ||
112 | let l:line.='%8* %{g:currentmode[mode()]}%*' | ||
113 | let l:line.=' ' | ||
114 | let l:line.=LinterStatus() | ||
115 | let l:line.=' ' | ||
116 | let l:line.='%8*'. &filetype | ||
117 | |||
118 | else | ||
119 | " inactive | ||
120 | let l:line.='%#Blanks#' | ||
121 | let l:line.='%f %5*%m%*' | ||
122 | let l:line.='%#Blanks# %=%*' | ||
123 | endif | ||
124 | |||
125 | let l:line.='%*' | ||
126 | |||
127 | return l:line | ||
128 | endfunction | ||
129 | |||
130 | set statusline=%!StatusLine('active') | ||
131 | augroup MyStatusLine | ||
132 | autocmd! | ||
133 | autocmd WinEnter * setl statusline=%!StatusLine('active') | ||
134 | autocmd WinLeave * setl statusline=%!StatusLine('inactive') | ||
135 | augroup END | ||
136 | |||
diff --git a/nvim/.config/nvim/plugin/textobjs.vim b/nvim/.config/nvim/plugin/textobjs.vim new file mode 100644 index 0000000..16f9a46 --- /dev/null +++ b/nvim/.config/nvim/plugin/textobjs.vim | |||
@@ -0,0 +1,27 @@ | |||
1 | " line text-objects | ||
2 | xnoremap il g_o^ | ||
3 | onoremap il :normal vil<CR> | ||
4 | xnoremap al $o0 | ||
5 | onoremap al :normal val<CR> | ||
6 | |||
7 | " buffer text-objects | ||
8 | " ------------------- | ||
9 | " i% a% | ||
10 | xnoremap i% :<C-u>let z = @/\|1;/^./kz<CR>G??<CR>:let @/ = z<CR>V'z | ||
11 | onoremap i% :normal vi%<CR> | ||
12 | xnoremap a% GoggV | ||
13 | onoremap a% :normal va%<CR> | ||
14 | |||
15 | " comment text-objects | ||
16 | " -------------------- | ||
17 | " i? a? | ||
18 | xnoremap <buffer> i? ?/\*<CR>o/\*\/<CR> | ||
19 | onoremap <buffer> i? :normal vi?<CR> | ||
20 | |||
21 | " square brackets text-objects | ||
22 | " ---------------------------- | ||
23 | " ir ar | ||
24 | xnoremap ir i[ | ||
25 | xnoremap ar a[ | ||
26 | onoremap ir :normal vi[<CR> | ||
27 | onoremap ar :normal va[<CR> | ||
diff --git a/nvim/.config/nvim/syntax/proto.vim b/nvim/.config/nvim/syntax/proto.vim new file mode 100644 index 0000000..8545631 --- /dev/null +++ b/nvim/.config/nvim/syntax/proto.vim | |||
@@ -0,0 +1,106 @@ | |||
1 | " Protocol Buffers - Google's data interchange format | ||
2 | " Copyright 2008 Google Inc. All rights reserved. | ||
3 | " https://developers.google.com/protocol-buffers/ | ||
4 | " | ||
5 | " Redistribution and use in source and binary forms, with or without | ||
6 | " modification, are permitted provided that the following conditions are | ||
7 | " met: | ||
8 | " | ||
9 | " * Redistributions of source code must retain the above copyright | ||
10 | " notice, this list of conditions and the following disclaimer. | ||
11 | " * Redistributions in binary form must reproduce the above | ||
12 | " copyright notice, this list of conditions and the following disclaimer | ||
13 | " in the documentation and/or other materials provided with the | ||
14 | " distribution. | ||
15 | " * Neither the name of Google Inc. nor the names of its | ||
16 | " contributors may be used to endorse or promote products derived from | ||
17 | " this software without specific prior written permission. | ||
18 | " | ||
19 | " THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
20 | " "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
21 | " LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
22 | " A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
23 | " OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
24 | " SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | ||
25 | " LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | ||
26 | " DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | ||
27 | " THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
28 | " (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | ||
29 | " OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
30 | |||
31 | " This is the Vim syntax file for Google Protocol Buffers. | ||
32 | " | ||
33 | " Usage: | ||
34 | " | ||
35 | " 1. cp proto.vim ~/.vim/syntax/ | ||
36 | " 2. Add the following to ~/.vimrc: | ||
37 | " | ||
38 | " augroup filetype | ||
39 | " au! BufRead,BufNewFile *.proto setfiletype proto | ||
40 | " augroup end | ||
41 | " | ||
42 | " Or just create a new file called ~/.vim/ftdetect/proto.vim with the | ||
43 | " previous lines on it. | ||
44 | |||
45 | if version < 600 | ||
46 | syntax clear | ||
47 | elseif exists("b:current_syntax") | ||
48 | finish | ||
49 | endif | ||
50 | |||
51 | syn case match | ||
52 | |||
53 | syn keyword pbTodo contained TODO FIXME XXX | ||
54 | syn cluster pbCommentGrp contains=pbTodo | ||
55 | |||
56 | syn keyword pbSyntax syntax import option | ||
57 | syn keyword pbStructure package message group oneof | ||
58 | syn keyword pbRepeat optional required repeated | ||
59 | syn keyword pbDefault default | ||
60 | syn keyword pbExtend extend extensions to max reserved | ||
61 | syn keyword pbRPC service rpc returns | ||
62 | |||
63 | syn keyword pbType int32 int64 uint32 uint64 sint32 sint64 | ||
64 | syn keyword pbType fixed32 fixed64 sfixed32 sfixed64 | ||
65 | syn keyword pbType float double bool string bytes | ||
66 | syn keyword pbTypedef enum | ||
67 | syn keyword pbBool true false | ||
68 | |||
69 | syn match pbInt /-\?\<\d\+\>/ | ||
70 | syn match pbInt /\<0[xX]\x+\>/ | ||
71 | syn match pbFloat /\<-\?\d*\(\.\d*\)\?/ | ||
72 | syn region pbComment start="\/\*" end="\*\/" contains=@pbCommentGrp | ||
73 | syn region pbComment start="//" skip="\\$" end="$" keepend contains=@pbCommentGrp | ||
74 | syn region pbString start=/"/ skip=/\\./ end=/"/ | ||
75 | syn region pbString start=/'/ skip=/\\./ end=/'/ | ||
76 | |||
77 | if version >= 508 || !exists("did_proto_syn_inits") | ||
78 | if version < 508 | ||
79 | let did_proto_syn_inits = 1 | ||
80 | command -nargs=+ HiLink hi link <args> | ||
81 | else | ||
82 | command -nargs=+ HiLink hi def link <args> | ||
83 | endif | ||
84 | |||
85 | HiLink pbTodo Todo | ||
86 | |||
87 | HiLink pbSyntax Include | ||
88 | HiLink pbStructure Structure | ||
89 | HiLink pbRepeat Repeat | ||
90 | HiLink pbDefault Keyword | ||
91 | HiLink pbExtend Keyword | ||
92 | HiLink pbRPC Keyword | ||
93 | HiLink pbType Type | ||
94 | HiLink pbTypedef Typedef | ||
95 | HiLink pbBool Boolean | ||
96 | |||
97 | HiLink pbInt Number | ||
98 | HiLink pbFloat Float | ||
99 | HiLink pbComment Comment | ||
100 | HiLink pbString String | ||
101 | |||
102 | delcommand HiLink | ||
103 | endif | ||
104 | |||
105 | let b:current_syntax = "proto" | ||
106 | |||