├── .gitignore
├── coc-settings.json
├── README.md
├── LICENSE
├── plugins.vim
├── init.vim.bak
├── init.vim
├── colors
    └── solarized.vim
└── autoload
    └── plug.vim


/.gitignore:
--------------------------------------------------------------------------------
1 | plugged
2 | undodir
3 | # autoload
4 | plugin
5 | 


--------------------------------------------------------------------------------
/coc-settings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "elixir.pathToElixirLS": "~/.elixir-ls/release/language_server.sh"
3 | }
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Neovim config
 2 | 
 3 | Simple & lightweight Neovim config
 4 | 
 5 | ![Neovim on macOS](http://afshinm.name/wp-content/uploads/2017/08/Screen-Shot-2017-08-04-at-17.59.44.png)
 6 | 
 7 | 
 8 | ## Install
 9 | 
10 | Please read this page: http://afshinm.name/neovim/
11 | 
12 | ## License
13 | 
14 | MIT
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Afshin Mehrabani
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/plugins.vim:
--------------------------------------------------------------------------------
 1 | " ============================================================================ "
 2 | " ===                               PLUGINS                                === "
 3 | " ============================================================================ "
 4 | 
 5 | " check whether vim-plug is installed and install it if necessary
 6 | let plugpath = expand('<sfile>:p:h'). '/autoload/plug.vim'
 7 | if !filereadable(plugpath)
 8 |     if executable('curl')
 9 |         let plugurl = 'https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
10 |         call system('curl -fLo ' . shellescape(plugpath) . ' --create-dirs ' . plugurl)
11 |         if v:shell_error
12 |             echom "Error downloading vim-plug. Please install it manually.\n"
13 |             exit
14 |         endif
15 |     else
16 |         echom "vim-plug not installed. Please install it manually or install curl.\n"
17 |         exit
18 |     endif
19 | endif
20 | 
21 | call plug#begin('~/.config/nvim/plugged')
22 | 
23 | " === Editing Plugins === "
24 | " Trailing whitespace highlighting & automatic fixing
25 | Plug 'ntpeters/vim-better-whitespace'
26 | 
27 | " auto-close plugin
28 | Plug 'rstacruz/vim-closer'
29 | 
30 | " Improved motion in Vim
31 | Plug 'easymotion/vim-easymotion'
32 | 
33 | " Intellisense Engine
34 | Plug 'neoclide/coc.nvim', {'branch': 'release'}
35 | 
36 | " Denite - Fuzzy finding, buffer management
37 | Plug 'Shougo/denite.nvim'
38 | 
39 | " Snippet support
40 | Plug 'Shougo/neosnippet'
41 | Plug 'Shougo/neosnippet-snippets'
42 | 
43 | " Print function signatures in echo area
44 | Plug 'Shougo/echodoc.vim'
45 | 
46 | " === Git Plugins === "
47 | " Enable git changes to be shown in sign column
48 | Plug 'mhinz/vim-signify'
49 | Plug 'tpope/vim-fugitive'
50 | 
51 | " === Javascript Plugins === "
52 | " Typescript syntax highlighting
53 | Plug 'HerringtonDarkholme/yats.vim'
54 | 
55 | " ReactJS JSX syntax highlighting
56 | Plug 'mxw/vim-jsx'
57 | 
58 | " Generate JSDoc commands based on function signature
59 | Plug 'heavenshell/vim-jsdoc'
60 | 
61 | " === Syntax Highlighting === "
62 | 
63 | " Syntax highlighting for nginx
64 | " Plug 'chr4/nginx.vim'
65 | 
66 | " Syntax highlighting for javascript libraries
67 | Plug 'othree/javascript-libraries-syntax.vim'
68 | 
69 | " Improved syntax highlighting and indentation
70 | Plug 'othree/yajs.vim'
71 | 
72 | " === UI === "
73 | " File explorer
74 | Plug 'scrooloose/nerdtree'
75 | 
76 | " Colorscheme
77 | " Plug 'mhartington/oceanic-next'
78 | " Plug 'dracula/vim'
79 | Plug 'joshdick/onedark.vim'
80 | 
81 | " Customized vim status line
82 | Plug 'vim-airline/vim-airline'
83 | Plug 'vim-airline/vim-airline-themes'
84 | 
85 | " Icons
86 | Plug 'ryanoasis/vim-devicons'
87 | Plug 'tiagofumo/vim-nerdtree-syntax-highlight'
88 | 
89 | Plug 'sheerun/vim-polyglot'
90 | 
91 | Plug 'elixir-editors/vim-elixir'
92 | " Plug 'amiralies/coc-elixir', {'do': 'yarn install --frozen-lockfile && yarn run build'}
93 | "
94 | Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
95 | Plug 'junegunn/fzf.vim'
96 | 
97 | " Initialize plugin system
98 | call plug#end()
99 | 


--------------------------------------------------------------------------------
/init.vim.bak:
--------------------------------------------------------------------------------
  1 | set spell spelllang=en_us
  2 | set undofile
  3 | set encoding=utf-8
  4 | 
  5 | if has('clipboard')
  6 |   if has('unnamedplus')  " When possible use + register for copy-paste
  7 |     set clipboard=unnamed,unnamedplus
  8 |   else         " On mac and Windows, use * register for copy-paste
  9 |     set clipboard=unnamed
 10 |   endif
 11 | endif
 12 | 
 13 | set ignorecase
 14 | set number
 15 | set conceallevel=1
 16 | set termguicolors
 17 | set background=dark
 18 | 
 19 | set expandtab
 20 | set autoindent
 21 | set softtabstop=4
 22 | set shiftwidth=2
 23 | set tabstop=4
 24 | 
 25 | set history=1000
 26 | 
 27 | " Visual shifting (does not exit Visual mode)
 28 | vnoremap < <gv
 29 | vnoremap > >gv
 30 | 
 31 | " Allow using the repeat operator with a visual selection (!)
 32 | " http://stackoverflow.com/a/8064607/127816
 33 | vnoremap . :normal .<CR>
 34 | 
 35 | " colorscheme OneDark
 36 | " colorscheme solarized
 37 | 
 38 | autocmd BufEnter * lcd %:p:h
 39 | 
 40 | filetype plugin indent on
 41 | 
 42 | set undodir=~/.config/nvim/undodir
 43 | 
 44 | call plug#begin()
 45 | 
 46 | Plug 'vim-scripts/Vimball'
 47 | Plug 'godlygeek/tabular'
 48 | Plug 'scrooloose/nerdtree'
 49 | Plug 'tpope/vim-fugitive'
 50 | Plug 'itchyny/lightline.vim'
 51 | Plug 'junegunn/goyo.vim'
 52 | Plug 'rust-lang/rust.vim'
 53 | Plug 'ctrlpvim/ctrlp.vim'
 54 | Plug 'groenewege/vim-less'
 55 | Plug 'tpope/vim-markdown'
 56 | Plug 'vim-scripts/nginx.vim'
 57 | Plug 'Valloric/YouCompleteMe'
 58 | Plug 'michaeljsmith/vim-indent-object'
 59 | Plug 'vim-syntastic/syntastic'
 60 | Plug 'Shougo/neocomplcache.vim'
 61 | Plug 'tpope/vim-surround'
 62 | Plug 'airblade/vim-gitgutter'
 63 | Plug 'pangloss/vim-javascript', { 'for': ['javascript', 'javascript.jsx'] }
 64 | Plug 'mxw/vim-jsx', { 'for': ['javascript', 'javascript.jsx'] }
 65 | Plug 'Raimondi/delimitMate'
 66 | Plug 'tmhedberg/SimpylFold'
 67 | Plug 'Vimjas/vim-python-pep8-indent'
 68 | Plug 'mhinz/vim-startify'
 69 | Plug 'vim-scripts/nginx.vim'
 70 | Plug 'leafgarland/typescript-vim'
 71 | Plug 'Quramy/tsuquyomi'
 72 | Plug 'Shougo/vimproc.vim'
 73 | Plug 'neoclide/coc.nvim', {'branch': 'release'}
 74 | Plug 'yggdroot/indentline'
 75 | Plug 'kien/rainbow_parentheses.vim'
 76 | Plug 'joshdick/onedark.vim'
 77 | 
 78 | if has('nvim')
 79 |   Plug 'Shougo/denite.nvim', { 'do': ':UpdateRemotePlugins' }
 80 | else
 81 |   Plug 'Shougo/denite.nvim'
 82 |   Plug 'roxma/nvim-yarp'
 83 |   Plug 'roxma/vim-hug-neovim-rpc'
 84 | endif
 85 | 
 86 | call plug#end()
 87 | 
 88 | let g:javascript_plugin_jsdoc           = 1
 89 | let g:javascript_conceal_function       = "ƒ"
 90 | let g:javascript_conceal_null           = "ø"
 91 | let g:javascript_conceal_arrow_function = "⇒"
 92 | let g:javascript_conceal_return         = "⇚"
 93 | 
 94 | let g:jsx_ext_required = 0
 95 | 
 96 | let g:syntastic_check_on_open=1
 97 | 
 98 | map <C-E> :NERDTreeToggle<CR>
 99 | let NERDTreeQuitOnOpen=1
100 | let NERDTreeShowHidden=1
101 | let NERDTreeIgnore = ['\.pyc$']
102 | 
103 | let g:ycm_autoclose_preview_window_after_completion=1
104 | 
105 | set foldmethod=indent
106 | set foldlevel=99
107 | 
108 | au BufRead,BufNewFile *.nginx set ft=nginx
109 | au BufRead,BufNewFile */etc/nginx/* set ft=nginx
110 | au BufRead,BufNewFile */usr/local/nginx/conf/* set ft=nginx
111 | au BufRead,BufNewFile nginx.conf set ft=nginx
112 | 
113 | set mouse=a                 " Automatically enable mouse usage
114 | set mousehide               " Hide the mouse cursor while typing
115 | 


--------------------------------------------------------------------------------
/init.vim:
--------------------------------------------------------------------------------
  1 | scriptencoding utf-8
  2 | source ~/.config/nvim/plugins.vim
  3 | 
  4 | " ============================================================================ "
  5 | " ===                           EDITING OPTIONS                            === "
  6 | " ============================================================================ "
  7 | 
  8 | " Remap leader key to ,
  9 | let g:mapleader=','
 10 | 
 11 | set encoding=UTF-8
 12 | set guifont=FiraCode\ Nerd\ Font 
 13 | 
 14 | " enable mouse
 15 | set mouse=a
 16 | 
 17 | " Disable line numbers
 18 | set nonumber
 19 | 
 20 | " Don't show last command
 21 | set noshowcmd
 22 | 
 23 | " Yank and paste with the system clipboard
 24 | set clipboard=unnamed
 25 | 
 26 | " Hides buffers instead of closing them
 27 | set hidden
 28 | 
 29 | " === TAB/Space settings === "
 30 | " Insert spaces when TAB is pressed.
 31 | set expandtab
 32 | 
 33 | " Change number of spaces that a <Tab> counts for during editing ops
 34 | set softtabstop=2
 35 | 
 36 | " Indentation amount for < and > commands.
 37 | set shiftwidth=2
 38 | 
 39 | " do not wrap long lines by default
 40 | set nowrap
 41 | 
 42 | " Don't highlight current cursor line
 43 | set nocursorline
 44 | 
 45 | " Disable line/column number in status line
 46 | " Shows up in preview window when airline is disabled if not
 47 | set noruler
 48 | 
 49 | " Only one line for command line
 50 | set cmdheight=1
 51 | 
 52 | " === Completion Settings === "
 53 | 
 54 | " Don't give completion messages like 'match 1 of 2'
 55 | " or 'The only match'
 56 | set shortmess+=c
 57 | 
 58 | " ============================================================================ "
 59 | " ===                           PLUGIN SETUP                               === "
 60 | "
 61 | " ============================================================================ "
 62 | 
 63 | " Wrap in try/catch to avoid errors on initial install before plugin is available
 64 | try
 65 | " === Denite setup ==="
 66 | " Use ripgrep for searching current directory for files
 67 | " By default, ripgrep will respect rules in .gitignore
 68 | "   --files: Print each file that would be searched (but don't search)
 69 | "   --glob:  Include or exclues files for searching that match the given glob
 70 | "            (aka ignore .git files)
 71 | "
 72 | call denite#custom#var('file/rec', 'command', ['rg', '--files', '--glob', '!.git'])
 73 | 
 74 | " Use ripgrep in place of "grep"
 75 | call denite#custom#var('grep', 'command', ['rg'])
 76 | 
 77 | " Custom options for ripgrep
 78 | "   --vimgrep:  Show results with every match on it's own line
 79 | "   --hidden:   Search hidden directories and files
 80 | "   --heading:  Show the file name above clusters of matches from each file
 81 | "   --S:        Search case insensitively if the pattern is all lowercase
 82 | call denite#custom#var('grep', 'default_opts', ['--hidden', '--vimgrep', '--heading', '-S'])
 83 | 
 84 | " Recommended defaults for ripgrep via Denite docs
 85 | call denite#custom#var('grep', 'recursive_opts', [])
 86 | call denite#custom#var('grep', 'pattern_opt', ['--regexp'])
 87 | call denite#custom#var('grep', 'separator', ['--'])
 88 | call denite#custom#var('grep', 'final_opts', [])
 89 | 
 90 | " Remove date from buffer list
 91 | call denite#custom#var('buffer', 'date_format', '')
 92 | 
 93 | " Custom options for Denite
 94 | "   auto_resize             - Auto resize the Denite window height automatically.
 95 | "   prompt                  - Customize denite prompt
 96 | "   direction               - Specify Denite window direction as directly below current pane
 97 | "   winminheight            - Specify min height for Denite window
 98 | "   highlight_mode_insert   - Specify h1-CursorLine in insert mode
 99 | "   prompt_highlight        - Specify color of prompt
100 | "   highlight_matched_char  - Matched characters highlight
101 | "   highlight_matched_range - matched range highlight
102 | let s:denite_options = {'default' : {
103 | \ 'split': 'floating',
104 | \ 'start_filter': 1,
105 | \ 'auto_resize': 1,
106 | \ 'source_names': 'short',
107 | \ 'prompt': 'λ ',
108 | \ 'highlight_matched_char': 'QuickFixLine',
109 | \ 'highlight_matched_range': 'Visual',
110 | \ 'highlight_window_background': 'Visual',
111 | \ 'highlight_filter_background': 'DiffAdd',
112 | \ 'winrow': 1,
113 | \ 'vertical_preview': 1
114 | \ }}
115 | 
116 | " Loop through denite options and enable them
117 | function! s:profile(opts) abort
118 |   for l:fname in keys(a:opts)
119 |     for l:dopt in keys(a:opts[l:fname])
120 |       call denite#custom#option(l:fname, l:dopt, a:opts[l:fname][l:dopt])
121 |     endfor
122 |   endfor
123 | endfunction
124 | 
125 | call s:profile(s:denite_options)
126 | catch
127 |   echo 'Denite not installed. It should work after running :PlugInstall'
128 | endtry
129 | 
130 | " === Coc.nvim === "
131 | " use <tab> for trigger completion and navigate to next complete item
132 | function! s:check_back_space() abort
133 |   let col = col('.') - 1
134 |   return !col || getline('.')[col - 1]  =~ '\s'
135 | endfunction
136 | 
137 | inoremap <silent><expr> <TAB>
138 |       \ pumvisible() ? "\<C-n>" :
139 |       \ <SID>check_back_space() ? "\<TAB>" :
140 |       \ coc#refresh()
141 | 
142 | "Close preview window when completion is done.
143 | autocmd! CompleteDone * if pumvisible() == 0 | pclose | endif
144 | 
145 | " === NeoSnippet === "
146 | " Map <C-k> as shortcut to activate snippet if available
147 | imap <C-k> <Plug>(neosnippet_expand_or_jump)
148 | smap <C-k> <Plug>(neosnippet_expand_or_jump)
149 | xmap <C-k> <Plug>(neosnippet_expand_target)
150 | 
151 | " from checkhealth
152 | let g:vimtex_compiler_progname='nvr'
153 | 
154 | " Load custom snippets from snippets folder
155 | let g:neosnippet#snippets_directory='~/.config/nvim/snippets'
156 | 
157 | " Hide conceal markers
158 | let g:neosnippet#enable_conceal_markers = 0
159 | 
160 | " === NERDTree === "
161 | " Show hidden files/directories
162 | let g:NERDTreeShowHidden = 1
163 | 
164 | " Remove bookmarks and help text from NERDTree
165 | let g:NERDTreeMinimalUI = 1
166 | 
167 | " Custom icons for expandable/expanded directories
168 | let g:NERDTreeDirArrowExpandable = '⬏'
169 | let g:NERDTreeDirArrowCollapsible = '⬎'
170 | 
171 | " Hide certain files and directories from NERDTree
172 | let g:NERDTreeIgnore = ['^\.DS_Store$', '^tags$', '\.git$[[dir]]', '\.idea$[[dir]]', '\.sass-cache$']
173 | 
174 | " Wrap in try/catch to avoid errors on initial install before plugin is available
175 | try
176 | 
177 | " === Vim airline ==== "
178 | " Enable extensions
179 | let g:airline_extensions = ['branch', 'hunks', 'coc']
180 | 
181 | " Update section z to just have line number
182 | let g:airline_section_z = airline#section#create(['linenr'])
183 | 
184 | " Do not draw separators for empty sections (only for the active window) >
185 | let g:airline_skip_empty_sections = 1
186 | 
187 | " Smartly uniquify buffers names with similar filename, suppressing common parts of paths.
188 | let g:airline#extensions#tabline#formatter = 'unique_tail'
189 | 
190 | " Custom setup that removes filetype/whitespace from default vim airline bar
191 | let g:airline#extensions#default#layout = [['a', 'b', 'c'], ['x', 'z', 'warning', 'error']]
192 | 
193 | " Customize vim airline per filetype
194 | " 'nerdtree'  - Hide nerdtree status line
195 | " 'list'      - Only show file type plus current line number out of total
196 | let g:airline_filetype_overrides = {
197 |   \ 'nerdtree': [ get(g:, 'NERDTreeStatusline', ''), '' ],
198 |   \ 'list': [ '%y', '%l/%L'],
199 |   \ }
200 | 
201 | " Enable powerline fonts
202 | let g:airline_powerline_fonts = 1
203 | 
204 | " Enable caching of syntax highlighting groups
205 | let g:airline_highlighting_cache = 1
206 | 
207 | " Define custom airline symbols
208 | if !exists('g:airline_symbols')
209 |   let g:airline_symbols = {}
210 | endif
211 | 
212 | " Don't show git changes to current file in airline
213 | let g:airline#extensions#hunks#enabled=0
214 | 
215 | catch
216 |   echo 'Airline not installed. It should work after running :PlugInstall'
217 | endtry
218 | 
219 | " === echodoc === "
220 | " Enable echodoc on startup
221 | let g:echodoc#enable_at_startup = 1
222 | 
223 | " === vim-javascript === "
224 | " Enable syntax highlighting for JSDoc
225 | let g:javascript_plugin_jsdoc = 1
226 | 
227 | " === vim-jsx === "
228 | " Highlight jsx syntax even in non .jsx files
229 | let g:jsx_ext_required = 0
230 | 
231 | " === javascript-libraries-syntax === "
232 | let g:used_javascript_libs = 'underscore,requirejs,chai,jquery'
233 | 
234 | " === Signify === "
235 | let g:signify_sign_delete = '-'
236 | 
237 | " ============================================================================ "
238 | " ===                                UI                                    === "
239 | " ============================================================================ "
240 | 
241 | " Enable true color support
242 | set termguicolors
243 | 
244 | " Vim airline theme
245 | let g:airline_theme='onedark'
246 | 
247 | " Change vertical split character to be a space (essentially hide it)
248 | set fillchars+=vert:.
249 | 
250 | " Set preview window to appear at bottom
251 | set splitbelow
252 | 
253 | " Don't dispay mode in command line (airilne already shows it)
254 | set noshowmode
255 | 
256 | " Set floating window to be slightly transparent
257 | set winbl=10
258 | 
259 | " ============================================================================ "
260 | " ===                      CUSTOM COLORSCHEME CHANGES                      === "
261 | " ============================================================================ "
262 | "
263 | " Add custom highlights in method that is executed every time a colorscheme is sourced
264 | " See https://gist.github.com/romainl/379904f91fa40533175dfaec4c833f2f for details
265 | function! TrailingSpaceHighlights() abort
266 |   " Hightlight trailing whitespace
267 |   highlight Trail ctermbg=red guibg=red
268 |   call matchadd('Trail', '\s\+$', 100)
269 | endfunction
270 | 
271 | function! s:custom_jarvis_colors()
272 |   " coc.nvim color changes
273 |   hi link CocErrorSign WarningMsg
274 |   hi link CocWarningSign Number
275 |   hi link CocInfoSign Type
276 | 
277 |   " Make background transparent for many things
278 |   hi Normal ctermbg=NONE guibg=NONE
279 |   hi NonText ctermbg=NONE guibg=NONE
280 |   hi LineNr ctermfg=NONE guibg=NONE
281 |   hi SignColumn ctermfg=NONE guibg=NONE
282 |   hi StatusLine guifg=#16252b guibg=#6699CC
283 |   hi StatusLineNC guifg=#16252b guibg=#16252b
284 | 
285 |   " Try to hide vertical spit and end of buffer symbol
286 |   hi VertSplit gui=NONE guifg=#17252c guibg=#17252c
287 |   hi EndOfBuffer ctermbg=NONE ctermfg=NONE guibg=#17252c guifg=#17252c
288 | 
289 |   " Customize NERDTree directory
290 |   hi NERDTreeCWD guifg=#99c794
291 | 
292 |   " Make background color transparent for git changes
293 |   hi SignifySignAdd guibg=NONE
294 |   hi SignifySignDelete guibg=NONE
295 |   hi SignifySignChange guibg=NONE
296 | 
297 |   " Highlight git change signs
298 |   hi SignifySignAdd guifg=#99c794
299 |   hi SignifySignDelete guifg=#ec5f67
300 |   hi SignifySignChange guifg=#c594c5
301 | endfunction
302 | 
303 | " autocmd! ColorScheme * call TrailingSpaceHighlights()
304 | " autocmd! ColorScheme OceanicNext call s:custom_jarvis_colors()
305 | 
306 | " Call method on window enter
307 | augroup WindowManagement
308 |   autocmd!
309 |   autocmd WinEnter * call Handle_Win_Enter()
310 | augroup END
311 | 
312 | " Change highlight group of preview window when open
313 | function! Handle_Win_Enter()
314 |   if &previewwindow
315 |     setlocal winhighlight=Normal:MarkdownError
316 |   endif
317 | endfunction
318 | 
319 | " Editor theme
320 | set background=dark
321 | try
322 |   " colorscheme OceanicNext
323 |   colorscheme onedark
324 | catch
325 |   colorscheme slate
326 | endtry
327 | " ============================================================================ "
328 | " ===                             KEY MAPPINGS                             === "
329 | " ============================================================================ "
330 | 
331 | " === Denite shorcuts === "
332 | "   ;         - Browser currently open buffers
333 | "   <leader>t - Browse list of files in current directory
334 | "   <leader>g - Search current directory for occurences of given term and close window if no results
335 | "   <leader>j - Search current directory for occurences of word under cursor
336 | nmap ; :Denite buffer<CR>
337 | nmap <leader>t :DeniteProjectDir file/rec<CR>
338 | nnoremap <leader>g :<C-u>Denite grep:. -no-empty<CR>
339 | nnoremap <leader>j :<C-u>DeniteCursorWord grep:.<CR>
340 | 
341 | " Define mappings while in 'filter' mode
342 | "   <C-o>         - Switch to normal mode inside of search results
343 | "   <Esc>         - Exit denite window in any mode
344 | "   <CR>          - Open currently selected file in any mode
345 | "   <C-t>         - Open currently selected file in a new tab
346 | "   <C-v>         - Open currently selected file a vertical split
347 | "   <C-h>         - Open currently selected file in a horizontal split
348 | autocmd FileType denite-filter call s:denite_filter_my_settings()
349 | function! s:denite_filter_my_settings() abort
350 |   imap <silent><buffer> <C-o>
351 |   \ <Plug>(denite_filter_quit)
352 |   inoremap <silent><buffer><expr> <Esc>
353 |   \ denite#do_map('quit')
354 |   nnoremap <silent><buffer><expr> <Esc>
355 |   \ denite#do_map('quit')
356 |   inoremap <silent><buffer><expr> <CR>
357 |   \ denite#do_map('do_action')
358 |   inoremap <silent><buffer><expr> <C-t>
359 |   \ denite#do_map('do_action', 'tabopen')
360 |   inoremap <silent><buffer><expr> <C-v>
361 |   \ denite#do_map('do_action', 'vsplit')
362 |   inoremap <silent><buffer><expr> <C-h>
363 |   \ denite#do_map('do_action', 'split')
364 | endfunction
365 | 
366 | " Define mappings while in denite window
367 | "   <CR>        - Opens currently selected file
368 | "   q or <Esc>  - Quit Denite window
369 | "   d           - Delete currenly selected file
370 | "   p           - Preview currently selected file
371 | "   <C-o> or i  - Switch to insert mode inside of filter prompt
372 | "   <C-t>       - Open currently selected file in a new tab
373 | "   <C-v>       - Open currently selected file a vertical split
374 | "   <C-h>       - Open currently selected file in a horizontal split
375 | autocmd FileType denite call s:denite_my_settings()
376 | function! s:denite_my_settings() abort
377 |   nnoremap <silent><buffer><expr> <CR>
378 |   \ denite#do_map('do_action')
379 |   nnoremap <silent><buffer><expr> q
380 |   \ denite#do_map('quit')
381 |   nnoremap <silent><buffer><expr> <Esc>
382 |   \ denite#do_map('quit')
383 |   nnoremap <silent><buffer><expr> d
384 |   \ denite#do_map('do_action', 'delete')
385 |   nnoremap <silent><buffer><expr> p
386 |   \ denite#do_map('do_action', 'preview')
387 |   nnoremap <silent><buffer><expr> i
388 |   \ denite#do_map('open_filter_buffer')
389 |   nnoremap <silent><buffer><expr> <C-o>
390 |   \ denite#do_map('open_filter_buffer')
391 |   nnoremap <silent><buffer><expr> <C-t>
392 |   \ denite#do_map('do_action', 'tabopen')
393 |   nnoremap <silent><buffer><expr> <C-v>
394 |   \ denite#do_map('do_action', 'vsplit')
395 |   nnoremap <silent><buffer><expr> <C-h>
396 |   \ denite#do_map('do_action', 'split')
397 | endfunction
398 | 
399 | " === Nerdtree shorcuts === "
400 | "  <leader>n - Toggle NERDTree on/off
401 | "  <leader>f - Opens current file location in NERDTree
402 | nmap <leader>n :NERDTreeToggle<CR>
403 | nmap <leader>f :NERDTreeFind<CR>
404 | 
405 | "   <Space> - PageDown
406 | "   -       - PageUp
407 | " noremap <Space> <PageDown>
408 | noremap - <PageUp>
409 | 
410 | " Quick window switching
411 | nmap <C-h> <C-w>h
412 | nmap <C-j> <C-w>j
413 | nmap <C-k> <C-w>k
414 | nmap <C-l> <C-w>l
415 | 
416 | " === coc.nvim === "
417 | "   <leader>dd    - Jump to definition of current symbol
418 | "   <leader>dr    - Jump to references of current symbol
419 | "   <leader>dj    - Jump to implementation of current symbol
420 | "   <leader>ds    - Fuzzy search current project symbols
421 | nmap <silent> <leader>dd <Plug>(coc-definition)
422 | nmap <silent> <leader>dr <Plug>(coc-references)
423 | nmap <silent> <leader>dj <Plug>(coc-implementation)
424 | nnoremap <silent> <leader>ds :<C-u>CocList -I -N --top symbols<CR>
425 | 
426 | " === vim-better-whitespace === "
427 | "   <leader>y - Automatically remove trailing whitespace
428 | nmap <leader>y :StripWhitespace<CR>
429 | 
430 | " === Search shorcuts === "
431 | "   <leader>h - Find and replace
432 | "   <leader>/ - Claer highlighted search terms while preserving history
433 | map <leader>h :%s///<left><left>
434 | nmap <silent> <leader>/ :nohlsearch<CR>
435 | 
436 | " === Easy-motion shortcuts ==="
437 | "   <leader>w - Easy-motion highlights first word letters bi-directionally
438 | map <leader>w <Plug>(easymotion-bd-w)
439 | 
440 | " Allows you to save files you opened without write permissions via sudo
441 | cmap w!! w !sudo tee %
442 | 
443 | " === vim-jsdoc shortcuts ==="
444 | " Generate jsdoc for function under cursor
445 | nmap <leader>z :JsDoc<CR>
446 | 
447 | " Delete current visual selection and dump in black hole buffer before pasting
448 | " Used when you want to paste over something without it getting copied to
449 | " Vim's default buffer
450 | vnoremap <leader>p "_dP
451 | 
452 | " ============================================================================ "
453 | " ===                                 MISC.                                === "
454 | " ============================================================================ "
455 | 
456 | " Automaticaly close nvim if NERDTree is only thing left open
457 | autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTree") && b:NERDTree.isTabTree()) | q | endif
458 | 
459 | " === Search === "
460 | " ignore case when searching
461 | set ignorecase
462 | 
463 | " if the search string has an upper case letter in it, the search will be case sensitive
464 | set smartcase
465 | 
466 | " Automatically re-read file if a change was detected outside of vim
467 | set autoread
468 | 
469 | " Enable line numbers
470 | set number
471 | 
472 | " Enable spellcheck for markdown files
473 | autocmd BufRead,BufNewFile *.md setlocal spell
474 | 
475 | " Set backups
476 | if has('persistent_undo')
477 |   set undofile
478 |   set undolevels=3000
479 |   set undoreload=10000
480 | endif
481 | set backupdir=~/.local/share/nvim/backup " Don't put backups in current dir
482 | set backup
483 | set noswapfile
484 | 
485 | " Reload icons after init source
486 | if exists('g:loaded_webdevicons')
487 |   call webdevicons#refresh()
488 | endif
489 | 
490 | nnoremap <C-p> :FZF<CR>
491 | let g:fzf_action = {
492 |   \ 'ctrl-t': 'tab split',
493 |   \ 'ctrl-s': 'split',
494 |   \ 'ctrl-v': 'vsplit'
495 |   \}
496 | 


--------------------------------------------------------------------------------
/colors/solarized.vim:
--------------------------------------------------------------------------------
  1 | " Name:     Solarized vim colorscheme
  2 | " Author:   Ethan Schoonover <es@ethanschoonover.com>
  3 | " URL:      http://ethanschoonover.com/solarized
  4 | "           (see this url for latest release & screenshots)
  5 | " License:  OSI approved MIT license (see end of this file)
  6 | " Created:  In the middle of the night
  7 | " Modified: 2011 May 05
  8 | "
  9 | " Usage "{{{
 10 | "
 11 | " ---------------------------------------------------------------------
 12 | " ABOUT:
 13 | " ---------------------------------------------------------------------
 14 | " Solarized is a carefully designed selective contrast colorscheme with dual
 15 | " light and dark modes that runs in both GUI, 256 and 16 color modes.
 16 | "
 17 | " See the homepage above for screenshots and details.
 18 | "
 19 | " ---------------------------------------------------------------------
 20 | " OPTIONS:
 21 | " ---------------------------------------------------------------------
 22 | " See the "solarized.txt" help file included with this colorscheme (in the 
 23 | " "doc" subdirectory) for information on options, usage, the Toggle Background 
 24 | " function and more. If you have already installed Solarized, this is available 
 25 | " from the Solarized menu and command line as ":help solarized"
 26 | "
 27 | " ---------------------------------------------------------------------
 28 | " INSTALLATION:
 29 | " ---------------------------------------------------------------------
 30 | " Two options for installation: manual or pathogen
 31 | "
 32 | " MANUAL INSTALLATION OPTION:
 33 | " ---------------------------------------------------------------------
 34 | "
 35 | " 1.  Download the solarized distribution (available on the homepage above)
 36 | "     and unarchive the file.
 37 | " 2.  Move `solarized.vim` to your `.vim/colors` directory.
 38 | " 3.  Move each of the files in each subdirectories to the corresponding .vim
 39 | "     subdirectory (e.g. autoload/togglebg.vim goes into your .vim/autoload 
 40 | "     directory as .vim/autoload/togglebg.vim).
 41 | "
 42 | " RECOMMENDED PATHOGEN INSTALLATION OPTION:
 43 | " ---------------------------------------------------------------------
 44 | "
 45 | " 1.  Download and install Tim Pope's Pathogen from:
 46 | "     https://github.com/tpope/vim-pathogen
 47 | "
 48 | " 2.  Next, move or clone the `vim-colors-solarized` directory so that it is
 49 | "     a subdirectory of the `.vim/bundle` directory.
 50 | "
 51 | "     a. **clone with git:**
 52 | "
 53 | "       $ cd ~/.vim/bundle
 54 | "       $ git clone git://github.com/altercation/vim-colors-solarized.git
 55 | "
 56 | "     b. **or move manually into the pathogen bundle directory:**
 57 | "         In the parent directory of vim-colors-solarized:
 58 | "
 59 | "         $ mv vim-colors-solarized ~/.vim/bundle/
 60 | "
 61 | " MODIFY VIMRC:
 62 | "
 63 | " After either Option 1 or Option 2 above, put the following two lines in your
 64 | " .vimrc:
 65 | "
 66 | "     syntax enable
 67 | "     set background=dark
 68 | "     colorscheme solarized
 69 | "
 70 | " or, for the light background mode of Solarized:
 71 | "
 72 | "     syntax enable
 73 | "     set background=light
 74 | "     colorscheme solarized
 75 | "
 76 | " I like to have a different background in GUI and terminal modes, so I can use
 77 | " the following if-then. However, I find vim's background autodetection to be
 78 | " pretty good and, at least with MacVim, I can leave this background value
 79 | " assignment out entirely and get the same results.
 80 | "
 81 | "     if has('gui_running')
 82 | "       set background=light
 83 | "     else
 84 | "       set background=dark
 85 | "     endif
 86 | "
 87 | " See the Solarized homepage at http://ethanschoonover.com/solarized for
 88 | " screenshots which will help you select either the light or dark background.
 89 | "
 90 | " ---------------------------------------------------------------------
 91 | " COLOR VALUES
 92 | " ---------------------------------------------------------------------
 93 | " Download palettes and files from: http://ethanschoonover.com/solarized
 94 | "
 95 | " L\*a\*b values are canonical (White D65, Reference D50), other values are
 96 | " matched in sRGB space.
 97 | "
 98 | " SOLARIZED HEX     16/8 TERMCOL  XTERM/HEX   L*A*B      sRGB        HSB
 99 | " --------- ------- ---- -------  ----------- ---------- ----------- -----------
100 | " base03    #002b36  8/4 brblack  234 #1c1c1c 15 -12 -12   0  43  54 193 100  21
101 | " base02    #073642  0/4 black    235 #262626 20 -12 -12   7  54  66 192  90  26
102 | " base01    #586e75 10/7 brgreen  240 #4e4e4e 45 -07 -07  88 110 117 194  25  46
103 | " base00    #657b83 11/7 bryellow 241 #585858 50 -07 -07 101 123 131 195  23  51
104 | " base0     #839496 12/6 brblue   244 #808080 60 -06 -03 131 148 150 186  13  59
105 | " base1     #93a1a1 14/4 brcyan   245 #8a8a8a 65 -05 -02 147 161 161 180   9  63
106 | " base2     #eee8d5  7/7 white    254 #d7d7af 92 -00  10 238 232 213  44  11  93
107 | " base3     #fdf6e3 15/7 brwhite  230 #ffffd7 97  00  10 253 246 227  44  10  99
108 | " yellow    #b58900  3/3 yellow   136 #af8700 60  10  65 181 137   0  45 100  71
109 | " orange    #cb4b16  9/3 brred    166 #d75f00 50  50  55 203  75  22  18  89  80
110 | " red       #dc322f  1/1 red      160 #d70000 50  65  45 220  50  47   1  79  86
111 | " magenta   #d33682  5/5 magenta  125 #af005f 50  65 -05 211  54 130 331  74  83
112 | " violet    #6c71c4 13/5 brmagenta 61 #5f5faf 50  15 -45 108 113 196 237  45  77
113 | " blue      #268bd2  4/4 blue      33 #0087ff 55 -10 -45  38 139 210 205  82  82
114 | " cyan      #2aa198  6/6 cyan      37 #00afaf 60 -35 -05  42 161 152 175  74  63
115 | " green     #859900  2/2 green     64 #5f8700 60 -20  65 133 153   0  68 100  60
116 | "
117 | " ---------------------------------------------------------------------
118 | " COLORSCHEME HACKING
119 | " ---------------------------------------------------------------------
120 | "
121 | " Useful commands for testing colorschemes:
122 | " :source $VIMRUNTIME/syntax/hitest.vim
123 | " :help highlight-groups
124 | " :help cterm-colors
125 | " :help group-name
126 | "
127 | " Useful links for developing colorschemes:
128 | " http://www.vim.org/scripts/script.php?script_id=2937
129 | " http://vimcasts.org/episodes/creating-colorschemes-for-vim/
130 | " http://www.frexx.de/xterm-256-notes/"
131 | "
132 | " }}}
133 | " Environment Specific Overrides "{{{
134 | " Allow or disallow certain features based on current terminal emulator or 
135 | " environment.
136 | 
137 | let s:terminal_italic=1
138 | 
139 | " }}}
140 | " Default option values"{{{
141 | " ---------------------------------------------------------------------
142 | " s:options_list is used to autogenerate a list of all non-default options 
143 | " using "call SolarizedOptions()" or with the "Generate .vimrc commands" 
144 | " Solarized menu option. See the "Menus" section below for the function itself.
145 | let s:options_list=[
146 |             \'" this block of commands has been autogenerated by solarized.vim and',
147 |             \'" includes the current, non-default Solarized option values.',
148 |             \'" To use, place these commands in your .vimrc file (replacing any',
149 |             \'" existing colorscheme commands). See also ":help solarized"',
150 |             \'',
151 |             \'" ------------------------------------------------------------------',
152 |             \'" Solarized Colorscheme Config',
153 |             \'" ------------------------------------------------------------------',
154 |             \]
155 | let s:colorscheme_list=[
156 |             \'syntax enable',
157 |             \'set background='.&background,
158 |             \'colorscheme solarized',
159 |             \]
160 | let s:defaults_list=[
161 |             \'" ------------------------------------------------------------------',
162 |             \'',
163 |             \'" The following items are available options, but do not need to be',
164 |             \'" included in your .vimrc as they are currently set to their defaults.',
165 |             \''
166 |             \]
167 | let s:lazycat_list=[
168 |             \'" lazy method of appending this onto your .vimrc ":w! >> ~/.vimrc"',
169 |             \'" ------------------------------------------------------------------',
170 |             \]
171 | 
172 | function! s:SetOption(name,default)
173 |     if type(a:default) == type(0)
174 |         let l:wrap=''
175 |         let l:ewrap=''
176 |     else
177 |         let l:wrap='"'
178 |         let l:ewrap='\"'
179 |     endif
180 |     if !exists("g:solarized_".a:name) || g:solarized_{a:name}==a:default
181 |         exe 'let g:solarized_'.a:name.'='.l:wrap.a:default.l:wrap.'"'
182 |         exe 'call add(s:defaults_list, "\" let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'")'
183 |     else
184 |         exe 'call add(s:options_list,  "let g:solarized_'.a:name.'='.l:ewrap.g:solarized_{a:name}.l:ewrap.'    \"default value is '.a:default.'")'
185 |     endif
186 | endfunction
187 | 
188 | if ($TERM_PROGRAM ==? "apple_terminal" && &t_Co < 256)
189 |     let s:solarized_termtrans_default = 1
190 | else
191 |     let s:solarized_termtrans_default = 0
192 | endif
193 | call s:SetOption("termtrans",s:solarized_termtrans_default)
194 | call s:SetOption("degrade",0)
195 | call s:SetOption("bold",1)
196 | call s:SetOption("underline",1)
197 | call s:SetOption("italic",1) " note that we need to override this later if the terminal doesn't support
198 | call s:SetOption("termcolors",16)
199 | call s:SetOption("contrast","normal")
200 | call s:SetOption("visibility","normal")
201 | call s:SetOption("diffmode","normal")
202 | call s:SetOption("hitrail",0)
203 | call s:SetOption("menu",1)
204 | 
205 | "}}}
206 | " Colorscheme initialization "{{{
207 | " ---------------------------------------------------------------------
208 | hi clear
209 | if exists("syntax_on")
210 |   syntax reset
211 | endif
212 | let colors_name = "solarized"
213 | 
214 | "}}}
215 | " GUI & CSApprox hexadecimal palettes"{{{
216 | " ---------------------------------------------------------------------
217 | "
218 | " Set both gui and terminal color values in separate conditional statements
219 | " Due to possibility that CSApprox is running (though I suppose we could just
220 | " leave the hex values out entirely in that case and include only cterm colors)
221 | " We also check to see if user has set solarized (force use of the
222 | " neutral gray monotone palette component)
223 | if (g:solarized_degrade == 0)
224 |     let s:vmode       = "gui"
225 |     let s:base03      = "#002b36"
226 |     let s:base02      = "#073642"
227 |     let s:base01      = "#586e75"
228 |     let s:base00      = "#657b83"
229 |     let s:base0       = "#839496"
230 |     let s:base1       = "#93a1a1"
231 |     let s:base2       = "#eee8d5"
232 |     let s:base3       = "#fdf6e3"
233 |     let s:yellow      = "#b58900"
234 |     let s:orange      = "#cb4b16"
235 |     let s:red         = "#dc322f"
236 |     let s:magenta     = "#d33682"
237 |     let s:violet      = "#6c71c4"
238 |     let s:blue        = "#268bd2"
239 |     let s:cyan        = "#2aa198"
240 |     "let s:green       = "#859900" "original
241 |     let s:green       = "#719e07" "experimental
242 | elseif (g:solarized_degrade == 1)
243 |     " These colors are identical to the 256 color mode. They may be viewed
244 |     " while in gui mode via "let g:solarized_degrade=1", though this is not
245 |     " recommened and is for testing only.
246 |     let s:vmode       = "gui"
247 |     let s:base03      = "#1c1c1c"
248 |     let s:base02      = "#262626"
249 |     let s:base01      = "#4e4e4e"
250 |     let s:base00      = "#585858"
251 |     let s:base0       = "#808080"
252 |     let s:base1       = "#8a8a8a"
253 |     let s:base2       = "#d7d7af"
254 |     let s:base3       = "#ffffd7"
255 |     let s:yellow      = "#af8700"
256 |     let s:orange      = "#d75f00"
257 |     let s:red         = "#af0000"
258 |     let s:magenta     = "#af005f"
259 |     let s:violet      = "#5f5faf"
260 |     let s:blue        = "#0087ff"
261 |     let s:cyan        = "#00afaf"
262 |     let s:green       = "#5f8700"
263 | endif
264 | "}}}
265 | " Formatting options and null values for passthrough effect "{{{
266 | " ---------------------------------------------------------------------
267 |     let s:none            = "NONE"
268 |     let s:none            = "NONE"
269 |     let s:t_none          = "NONE"
270 |     let s:n               = "NONE"
271 |     let s:c               = ",undercurl"
272 |     let s:r               = ",reverse"
273 |     let s:s               = ",standout"
274 |     let s:ou              = ""
275 |     let s:ob              = ""
276 | "}}}
277 | " Background value based on termtrans setting "{{{
278 | " ---------------------------------------------------------------------
279 | if (g:solarized_termtrans == 0)
280 |     let s:back        = s:base03
281 | else
282 |     let s:back        = "NONE"
283 | endif
284 | "}}}
285 | " Alternate light scheme "{{{
286 | " ---------------------------------------------------------------------
287 | if &background == "light"
288 |     let s:temp03      = s:base03
289 |     let s:temp02      = s:base02
290 |     let s:temp01      = s:base01
291 |     let s:temp00      = s:base00
292 |     let s:base03      = s:base3
293 |     let s:base02      = s:base2
294 |     let s:base01      = s:base1
295 |     let s:base00      = s:base0
296 |     let s:base0       = s:temp00
297 |     let s:base1       = s:temp01
298 |     let s:base2       = s:temp02
299 |     let s:base3       = s:temp03
300 |     if (s:back != "NONE")
301 |         let s:back    = s:base03
302 |     endif
303 | endif
304 | "}}}
305 | " Optional contrast schemes "{{{
306 | " ---------------------------------------------------------------------
307 | if g:solarized_contrast == "high"
308 |     let s:base01      = s:base00
309 |     let s:base00      = s:base0
310 |     let s:base0       = s:base1
311 |     let s:base1       = s:base2
312 |     let s:base2       = s:base3
313 |     let s:back        = s:back
314 | endif
315 | if g:solarized_contrast == "low"
316 |     let s:back        = s:base02
317 |     let s:ou          = ",underline"
318 | endif
319 | "}}}
320 | " Overrides dependent on user specified values and environment "{{{
321 | " ---------------------------------------------------------------------
322 | if (g:solarized_bold == 0 || &t_Co == 8 )
323 |     let s:b           = ""
324 |     let s:bb          = ",bold"
325 | else
326 |     let s:b           = ",bold"
327 |     let s:bb          = ""
328 | endif
329 | 
330 | if g:solarized_underline == 0
331 |     let s:u           = ""
332 | else
333 |     let s:u           = ",underline"
334 | endif
335 | 
336 | if g:solarized_italic == 0 || s:terminal_italic == 0
337 |     let s:i           = ""
338 | else
339 |     let s:i           = ",italic"
340 | endif
341 | "}}}
342 | " Highlighting primitives"{{{
343 | " ---------------------------------------------------------------------
344 | 
345 | exe "let s:bg_none      = ' ".s:vmode."bg=".s:none   ."'"
346 | exe "let s:bg_back      = ' ".s:vmode."bg=".s:back   ."'"
347 | exe "let s:bg_base03    = ' ".s:vmode."bg=".s:base03 ."'"
348 | exe "let s:bg_base02    = ' ".s:vmode."bg=".s:base02 ."'"
349 | exe "let s:bg_base01    = ' ".s:vmode."bg=".s:base01 ."'"
350 | exe "let s:bg_base00    = ' ".s:vmode."bg=".s:base00 ."'"
351 | exe "let s:bg_base0     = ' ".s:vmode."bg=".s:base0  ."'"
352 | exe "let s:bg_base1     = ' ".s:vmode."bg=".s:base1  ."'"
353 | exe "let s:bg_base2     = ' ".s:vmode."bg=".s:base2  ."'"
354 | exe "let s:bg_base3     = ' ".s:vmode."bg=".s:base3  ."'"
355 | exe "let s:bg_green     = ' ".s:vmode."bg=".s:green  ."'"
356 | exe "let s:bg_yellow    = ' ".s:vmode."bg=".s:yellow ."'"
357 | exe "let s:bg_orange    = ' ".s:vmode."bg=".s:orange ."'"
358 | exe "let s:bg_red       = ' ".s:vmode."bg=".s:red    ."'"
359 | exe "let s:bg_magenta   = ' ".s:vmode."bg=".s:magenta."'"
360 | exe "let s:bg_violet    = ' ".s:vmode."bg=".s:violet ."'"
361 | exe "let s:bg_blue      = ' ".s:vmode."bg=".s:blue   ."'"
362 | exe "let s:bg_cyan      = ' ".s:vmode."bg=".s:cyan   ."'"
363 | 
364 | exe "let s:fg_none      = ' ".s:vmode."fg=".s:none   ."'"
365 | exe "let s:fg_back      = ' ".s:vmode."fg=".s:back   ."'"
366 | exe "let s:fg_base03    = ' ".s:vmode."fg=".s:base03 ."'"
367 | exe "let s:fg_base02    = ' ".s:vmode."fg=".s:base02 ."'"
368 | exe "let s:fg_base01    = ' ".s:vmode."fg=".s:base01 ."'"
369 | exe "let s:fg_base00    = ' ".s:vmode."fg=".s:base00 ."'"
370 | exe "let s:fg_base0     = ' ".s:vmode."fg=".s:base0  ."'"
371 | exe "let s:fg_base1     = ' ".s:vmode."fg=".s:base1  ."'"
372 | exe "let s:fg_base2     = ' ".s:vmode."fg=".s:base2  ."'"
373 | exe "let s:fg_base3     = ' ".s:vmode."fg=".s:base3  ."'"
374 | exe "let s:fg_green     = ' ".s:vmode."fg=".s:green  ."'"
375 | exe "let s:fg_yellow    = ' ".s:vmode."fg=".s:yellow ."'"
376 | exe "let s:fg_orange    = ' ".s:vmode."fg=".s:orange ."'"
377 | exe "let s:fg_red       = ' ".s:vmode."fg=".s:red    ."'"
378 | exe "let s:fg_magenta   = ' ".s:vmode."fg=".s:magenta."'"
379 | exe "let s:fg_violet    = ' ".s:vmode."fg=".s:violet ."'"
380 | exe "let s:fg_blue      = ' ".s:vmode."fg=".s:blue   ."'"
381 | exe "let s:fg_cyan      = ' ".s:vmode."fg=".s:cyan   ."'"
382 | 
383 | exe "let s:fmt_none     = ' ".s:vmode."=NONE".          " term=NONE".    "'"
384 | exe "let s:fmt_bold     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
385 | exe "let s:fmt_bldi     = ' ".s:vmode."=NONE".s:b.      " term=NONE".s:b."'"
386 | exe "let s:fmt_undr     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
387 | exe "let s:fmt_undb     = ' ".s:vmode."=NONE".s:u.s:b.  " term=NONE".s:u.s:b."'"
388 | exe "let s:fmt_undi     = ' ".s:vmode."=NONE".s:u.      " term=NONE".s:u."'"
389 | exe "let s:fmt_uopt     = ' ".s:vmode."=NONE".s:ou.     " term=NONE".s:ou."'"
390 | exe "let s:fmt_curl     = ' ".s:vmode."=NONE".s:c.      " term=NONE".s:c."'"
391 | exe "let s:fmt_ital     = ' ".s:vmode."=NONE".s:i.      " term=NONE".s:i."'"
392 | exe "let s:fmt_stnd     = ' ".s:vmode."=NONE".s:s.      " term=NONE".s:s."'"
393 | exe "let s:fmt_revr     = ' ".s:vmode."=NONE".s:r.      " term=NONE".s:r."'"
394 | exe "let s:fmt_revb     = ' ".s:vmode."=NONE".s:r.s:b.  " term=NONE".s:r.s:b."'"
395 | " revbb (reverse bold for bright colors) is only set to actual bold in low 
396 | " color terminals (t_co=8, such as OS X Terminal.app) and should only be used 
397 | " with colors 8-15.
398 | exe "let s:fmt_revbb    = ' ".s:vmode."=NONE".s:r.s:bb.   " term=NONE".s:r.s:bb."'"
399 | exe "let s:fmt_revbbu   = ' ".s:vmode."=NONE".s:r.s:bb.s:u." term=NONE".s:r.s:bb.s:u."'"
400 | 
401 | exe "let s:sp_none      = ' guisp=".s:none   ."'"
402 | exe "let s:sp_back      = ' guisp=".s:back   ."'"
403 | exe "let s:sp_base03    = ' guisp=".s:base03 ."'"
404 | exe "let s:sp_base02    = ' guisp=".s:base02 ."'"
405 | exe "let s:sp_base01    = ' guisp=".s:base01 ."'"
406 | exe "let s:sp_base00    = ' guisp=".s:base00 ."'"
407 | exe "let s:sp_base0     = ' guisp=".s:base0  ."'"
408 | exe "let s:sp_base1     = ' guisp=".s:base1  ."'"
409 | exe "let s:sp_base2     = ' guisp=".s:base2  ."'"
410 | exe "let s:sp_base3     = ' guisp=".s:base3  ."'"
411 | exe "let s:sp_green     = ' guisp=".s:green  ."'"
412 | exe "let s:sp_yellow    = ' guisp=".s:yellow ."'"
413 | exe "let s:sp_orange    = ' guisp=".s:orange ."'"
414 | exe "let s:sp_red       = ' guisp=".s:red    ."'"
415 | exe "let s:sp_magenta   = ' guisp=".s:magenta."'"
416 | exe "let s:sp_violet    = ' guisp=".s:violet ."'"
417 | exe "let s:sp_blue      = ' guisp=".s:blue   ."'"
418 | exe "let s:sp_cyan      = ' guisp=".s:cyan   ."'"
419 | 
420 | "}}}
421 | " Basic highlighting"{{{
422 | " ---------------------------------------------------------------------
423 | " note that link syntax to avoid duplicate configuration doesn't work with the
424 | " exe compiled formats
425 | 
426 | exe "hi! Normal"         .s:fmt_none   .s:fg_base0  .s:bg_back
427 | 
428 | exe "hi! Comment"        .s:fmt_ital   .s:fg_base01 .s:bg_none
429 | "       *Comment         any comment
430 | 
431 | exe "hi! Constant"       .s:fmt_none   .s:fg_cyan   .s:bg_none
432 | "       *Constant        any constant
433 | "        String          a string constant: "this is a string"
434 | "        Character       a character constant: 'c', '\n'
435 | "        Number          a number constant: 234, 0xff
436 | "        Boolean         a boolean constant: TRUE, false
437 | "        Float           a floating point constant: 2.3e10
438 | 
439 | exe "hi! Identifier"     .s:fmt_none   .s:fg_blue   .s:bg_none
440 | "       *Identifier      any variable name
441 | "        Function        function name (also: methods for classes)
442 | "
443 | exe "hi! Statement"      .s:fmt_none   .s:fg_green  .s:bg_none
444 | "       *Statement       any statement
445 | "        Conditional     if, then, else, endif, switch, etc.
446 | "        Repeat          for, do, while, etc.
447 | "        Label           case, default, etc.
448 | "        Operator        "sizeof", "+", "*", etc.
449 | "        Keyword         any other keyword
450 | "        Exception       try, catch, throw
451 | 
452 | exe "hi! PreProc"        .s:fmt_none   .s:fg_orange .s:bg_none
453 | "       *PreProc         generic Preprocessor
454 | "        Include         preprocessor #include
455 | "        Define          preprocessor #define
456 | "        Macro           same as Define
457 | "        PreCondit       preprocessor #if, #else, #endif, etc.
458 | 
459 | exe "hi! Type"           .s:fmt_none   .s:fg_yellow .s:bg_none
460 | "       *Type            int, long, char, etc.
461 | "        StorageClass    static, register, volatile, etc.
462 | "        Structure       struct, union, enum, etc.
463 | "        Typedef         A typedef
464 | 
465 | exe "hi! Special"        .s:fmt_none   .s:fg_red    .s:bg_none
466 | "       *Special         any special symbol
467 | "        SpecialChar     special character in a constant
468 | "        Tag             you can use CTRL-] on this
469 | "        Delimiter       character that needs attention
470 | "        SpecialComment  special things inside a comment
471 | "        Debug           debugging statements
472 | 
473 | exe "hi! Underlined"     .s:fmt_none   .s:fg_violet .s:bg_none
474 | "       *Underlined      text that stands out, HTML links
475 | 
476 | exe "hi! Ignore"         .s:fmt_none   .s:fg_none   .s:bg_none
477 | "       *Ignore          left blank, hidden  |hl-Ignore|
478 | 
479 | exe "hi! Error"          .s:fmt_bold   .s:fg_red    .s:bg_none
480 | "       *Error           any erroneous construct
481 | 
482 | exe "hi! Todo"           .s:fmt_bold   .s:fg_magenta.s:bg_none
483 | "       *Todo            anything that needs extra attention; mostly the
484 | "                        keywords TODO FIXME and XXX
485 | "
486 | "}}}
487 | " Extended highlighting "{{{
488 | " ---------------------------------------------------------------------
489 | if      (g:solarized_visibility=="high")
490 |     exe "hi! SpecialKey" .s:fmt_revr   .s:fg_red    .s:bg_none
491 |     exe "hi! NonText"    .s:fmt_bold   .s:fg_red    .s:bg_none
492 | elseif  (g:solarized_visibility=="low")
493 |     exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base02 .s:bg_none
494 |     exe "hi! NonText"    .s:fmt_bold   .s:fg_base02 .s:bg_none
495 | else
496 |     exe "hi! SpecialKey" .s:fmt_bold   .s:fg_base00 .s:bg_base02
497 |     exe "hi! NonText"    .s:fmt_bold   .s:fg_base00 .s:bg_none
498 | endif
499 | exe "hi! StatusLine"     .s:fmt_none   .s:fg_base1  .s:bg_base02 .s:fmt_revbb
500 | exe "hi! StatusLineNC"   .s:fmt_none   .s:fg_base00 .s:bg_base02 .s:fmt_revbb
501 | exe "hi! Visual"         .s:fmt_none   .s:fg_base01 .s:bg_base03 .s:fmt_revbb
502 | exe "hi! Directory"      .s:fmt_none   .s:fg_blue   .s:bg_none
503 | exe "hi! ErrorMsg"       .s:fmt_revr   .s:fg_red    .s:bg_none
504 | exe "hi! IncSearch"      .s:fmt_stnd   .s:fg_orange .s:bg_none
505 | exe "hi! Search"         .s:fmt_revr   .s:fg_yellow .s:bg_none
506 | exe "hi! MoreMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
507 | exe "hi! ModeMsg"        .s:fmt_none   .s:fg_blue   .s:bg_none
508 | exe "hi! LineNr"         .s:fmt_none   .s:fg_base01 .s:bg_base02
509 | exe "hi! Question"       .s:fmt_bold   .s:fg_cyan   .s:bg_none
510 | exe "hi! VertSplit"  .s:fmt_none   .s:fg_base00 .s:bg_base00
511 | exe "hi! Title"          .s:fmt_bold   .s:fg_orange .s:bg_none
512 | exe "hi! VisualNOS"      .s:fmt_stnd   .s:fg_none   .s:bg_base02 .s:fmt_revbb
513 | exe "hi! WarningMsg"     .s:fmt_bold   .s:fg_red    .s:bg_none
514 | exe "hi! WildMenu"       .s:fmt_none   .s:fg_base2  .s:bg_base02 .s:fmt_revbb
515 | exe "hi! Folded"         .s:fmt_undb   .s:fg_base0  .s:bg_base02  .s:sp_base03
516 | exe "hi! FoldColumn"     .s:fmt_none   .s:fg_base0  .s:bg_base02
517 | if      (g:solarized_diffmode=="high")
518 | exe "hi! DiffAdd"        .s:fmt_revr   .s:fg_green  .s:bg_none
519 | exe "hi! DiffChange"     .s:fmt_revr   .s:fg_yellow .s:bg_none
520 | exe "hi! DiffDelete"     .s:fmt_revr   .s:fg_red    .s:bg_none
521 | exe "hi! DiffText"       .s:fmt_revr   .s:fg_blue   .s:bg_none
522 | elseif  (g:solarized_diffmode=="low")
523 | exe "hi! DiffAdd"        .s:fmt_undr   .s:fg_green  .s:bg_none   .s:sp_green
524 | exe "hi! DiffChange"     .s:fmt_undr   .s:fg_yellow .s:bg_none   .s:sp_yellow
525 | exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_none
526 | exe "hi! DiffText"       .s:fmt_undr   .s:fg_blue   .s:bg_none   .s:sp_blue
527 | else " normal
528 | exe "hi! DiffAdd"        .s:fmt_bold   .s:fg_green  .s:bg_base02 .s:sp_green
529 | exe "hi! DiffChange"     .s:fmt_bold   .s:fg_yellow .s:bg_base02 .s:sp_yellow
530 | exe "hi! DiffDelete"     .s:fmt_bold   .s:fg_red    .s:bg_base02
531 | exe "hi! DiffText"       .s:fmt_bold   .s:fg_blue   .s:bg_base02 .s:sp_blue
532 | endif
533 | hi! link SignColumn LineNr
534 | exe "hi! Conceal"        .s:fmt_none   .s:fg_blue   .s:bg_none
535 | exe "hi! SpellBad"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_red
536 | exe "hi! SpellCap"       .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_violet
537 | exe "hi! SpellRare"      .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_cyan
538 | exe "hi! SpellLocal"     .s:fmt_curl   .s:fg_none   .s:bg_none    .s:sp_yellow
539 | exe "hi! Pmenu"          .s:fmt_none   .s:fg_base0  .s:bg_base02  .s:fmt_revbb
540 | exe "hi! PmenuSel"       .s:fmt_none   .s:fg_base01 .s:bg_base2   .s:fmt_revbb
541 | exe "hi! PmenuSbar"      .s:fmt_none   .s:fg_base2  .s:bg_base0   .s:fmt_revbb
542 | exe "hi! PmenuThumb"     .s:fmt_none   .s:fg_base0  .s:bg_base03  .s:fmt_revbb
543 | exe "hi! TabLine"        .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
544 | exe "hi! TabLineFill"    .s:fmt_undr   .s:fg_base0  .s:bg_base02  .s:sp_base0
545 | exe "hi! TabLineSel"     .s:fmt_undr   .s:fg_base01 .s:bg_base2   .s:sp_base0  .s:fmt_revbbu
546 | exe "hi! CursorColumn"   .s:fmt_none   .s:fg_none   .s:bg_base02
547 | exe "hi! CursorLine"     .s:fmt_uopt   .s:fg_none   .s:bg_base02  .s:sp_base1
548 | exe "hi! CursorLineNr"   .s:fmt_uopt   .s:fg_none   .s:bg_base02
549 | exe "hi! ColorColumn"    .s:fmt_none   .s:fg_none   .s:bg_base02
550 | exe "hi! Cursor"         .s:fmt_none   .s:fg_base03 .s:bg_base0
551 | hi! link lCursor Cursor
552 | exe "hi! MatchParen"     .s:fmt_bold   .s:fg_red    .s:bg_base01
553 | 
554 | "}}}
555 | " vim syntax highlighting "{{{
556 | " ---------------------------------------------------------------------
557 | "exe "hi! vimLineComment" . s:fg_base01 .s:bg_none   .s:fmt_ital
558 | "hi! link vimComment Comment
559 | "hi! link vimLineComment Comment
560 | hi! link vimVar Identifier
561 | hi! link vimFunc Function
562 | hi! link vimUserFunc Function
563 | hi! link helpSpecial Special
564 | hi! link vimSet Normal
565 | hi! link vimSetEqual Normal
566 | exe "hi! vimCommentString"  .s:fmt_none    .s:fg_violet .s:bg_none
567 | exe "hi! vimCommand"        .s:fmt_none    .s:fg_yellow .s:bg_none
568 | exe "hi! vimCmdSep"         .s:fmt_bold    .s:fg_blue   .s:bg_none
569 | exe "hi! helpExample"       .s:fmt_none    .s:fg_base1  .s:bg_none
570 | exe "hi! helpOption"        .s:fmt_none    .s:fg_cyan   .s:bg_none
571 | exe "hi! helpNote"          .s:fmt_none    .s:fg_magenta.s:bg_none
572 | exe "hi! helpVim"           .s:fmt_none    .s:fg_magenta.s:bg_none
573 | exe "hi! helpHyperTextJump" .s:fmt_undr    .s:fg_blue   .s:bg_none
574 | exe "hi! helpHyperTextEntry".s:fmt_none    .s:fg_green  .s:bg_none
575 | exe "hi! vimIsCommand"      .s:fmt_none    .s:fg_base00 .s:bg_none
576 | exe "hi! vimSynMtchOpt"     .s:fmt_none    .s:fg_yellow .s:bg_none
577 | exe "hi! vimSynType"        .s:fmt_none    .s:fg_cyan   .s:bg_none
578 | exe "hi! vimHiLink"         .s:fmt_none    .s:fg_blue   .s:bg_none
579 | exe "hi! vimHiGroup"        .s:fmt_none    .s:fg_blue   .s:bg_none
580 | exe "hi! vimGroup"          .s:fmt_undb    .s:fg_blue   .s:bg_none
581 |  "}}}
582 | " diff highlighting "{{{
583 | " ---------------------------------------------------------------------
584 | hi! link diffAdded Statement
585 | hi! link diffLine Identifier
586 | "}}}
587 | " git & gitcommit highlighting "{{{
588 | "git
589 | "exe "hi! gitDateHeader"
590 | "exe "hi! gitIdentityHeader"
591 | "exe "hi! gitIdentityKeyword"
592 | "exe "hi! gitNotesHeader"
593 | "exe "hi! gitReflogHeader"
594 | "exe "hi! gitKeyword"
595 | "exe "hi! gitIdentity"
596 | "exe "hi! gitEmailDelimiter"
597 | "exe "hi! gitEmail"
598 | "exe "hi! gitDate"
599 | "exe "hi! gitMode"
600 | "exe "hi! gitHashAbbrev"
601 | "exe "hi! gitHash"
602 | "exe "hi! gitReflogMiddle"
603 | "exe "hi! gitReference"
604 | "exe "hi! gitStage"
605 | "exe "hi! gitType"
606 | "exe "hi! gitDiffAdded"
607 | "exe "hi! gitDiffRemoved"
608 | "gitcommit
609 | "exe "hi! gitcommitSummary"      
610 | exe "hi! gitcommitComment"      .s:fmt_ital     .s:fg_base01    .s:bg_none
611 | hi! link gitcommitUntracked gitcommitComment
612 | hi! link gitcommitDiscarded gitcommitComment
613 | hi! link gitcommitSelected  gitcommitComment
614 | exe "hi! gitcommitUnmerged"     .s:fmt_bold     .s:fg_green     .s:bg_none
615 | exe "hi! gitcommitOnBranch"     .s:fmt_bold     .s:fg_base01    .s:bg_none
616 | exe "hi! gitcommitBranch"       .s:fmt_bold     .s:fg_magenta   .s:bg_none
617 | hi! link gitcommitNoBranch gitcommitBranch
618 | exe "hi! gitcommitDiscardedType".s:fmt_none     .s:fg_red       .s:bg_none
619 | exe "hi! gitcommitSelectedType" .s:fmt_none     .s:fg_green     .s:bg_none
620 | "exe "hi! gitcommitUnmergedType"
621 | "exe "hi! gitcommitType"
622 | "exe "hi! gitcommitNoChanges"
623 | "exe "hi! gitcommitHeader"
624 | exe "hi! gitcommitHeader"       .s:fmt_none     .s:fg_base01    .s:bg_none
625 | exe "hi! gitcommitUntrackedFile".s:fmt_bold     .s:fg_cyan      .s:bg_none
626 | exe "hi! gitcommitDiscardedFile".s:fmt_bold     .s:fg_red       .s:bg_none
627 | exe "hi! gitcommitSelectedFile" .s:fmt_bold     .s:fg_green     .s:bg_none
628 | exe "hi! gitcommitUnmergedFile" .s:fmt_bold     .s:fg_yellow    .s:bg_none
629 | exe "hi! gitcommitFile"         .s:fmt_bold     .s:fg_base0     .s:bg_none
630 | hi! link gitcommitDiscardedArrow gitcommitDiscardedFile
631 | hi! link gitcommitSelectedArrow  gitcommitSelectedFile
632 | hi! link gitcommitUnmergedArrow  gitcommitUnmergedFile
633 | "exe "hi! gitcommitArrow"
634 | "exe "hi! gitcommitOverflow"
635 | "exe "hi! gitcommitBlank"
636 | " }}}
637 | " html highlighting "{{{
638 | " ---------------------------------------------------------------------
639 | exe "hi! htmlTag"           .s:fmt_none .s:fg_base01 .s:bg_none
640 | exe "hi! htmlEndTag"        .s:fmt_none .s:fg_base01 .s:bg_none
641 | exe "hi! htmlTagN"          .s:fmt_bold .s:fg_base1  .s:bg_none
642 | exe "hi! htmlTagName"       .s:fmt_bold .s:fg_blue   .s:bg_none
643 | exe "hi! htmlSpecialTagName".s:fmt_ital .s:fg_blue   .s:bg_none
644 | exe "hi! htmlArg"           .s:fmt_none .s:fg_base00 .s:bg_none
645 | exe "hi! javaScript"        .s:fmt_none .s:fg_yellow .s:bg_none
646 | "}}}
647 | " perl highlighting "{{{
648 | " ---------------------------------------------------------------------
649 | exe "hi! perlHereDoc"    . s:fg_base1  .s:bg_back   .s:fmt_none
650 | exe "hi! perlVarPlain"   . s:fg_yellow .s:bg_back   .s:fmt_none
651 | exe "hi! perlStatementFileDesc". s:fg_cyan.s:bg_back.s:fmt_none
652 | 
653 | "}}}
654 | " tex highlighting "{{{
655 | " ---------------------------------------------------------------------
656 | exe "hi! texStatement"   . s:fg_cyan   .s:bg_back   .s:fmt_none
657 | exe "hi! texMathZoneX"   . s:fg_yellow .s:bg_back   .s:fmt_none
658 | exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
659 | exe "hi! texMathMatcher" . s:fg_yellow .s:bg_back   .s:fmt_none
660 | exe "hi! texRefLabel"    . s:fg_yellow .s:bg_back   .s:fmt_none
661 | "}}}
662 | " ruby highlighting "{{{
663 | " ---------------------------------------------------------------------
664 | exe "hi! rubyDefine"     . s:fg_base1  .s:bg_back   .s:fmt_bold
665 | "rubyInclude
666 | "rubySharpBang
667 | "rubyAccess
668 | "rubyPredefinedVariable
669 | "rubyBoolean
670 | "rubyClassVariable
671 | "rubyBeginEnd
672 | "rubyRepeatModifier
673 | "hi! link rubyArrayDelimiter    Special  " [ , , ]
674 | "rubyCurlyBlock  { , , }
675 | 
676 | "hi! link rubyClass             Keyword
677 | "hi! link rubyModule            Keyword
678 | "hi! link rubyKeyword           Keyword
679 | "hi! link rubyOperator          Operator
680 | "hi! link rubyIdentifier        Identifier
681 | "hi! link rubyInstanceVariable  Identifier
682 | "hi! link rubyGlobalVariable    Identifier
683 | "hi! link rubyClassVariable     Identifier
684 | "hi! link rubyConstant          Type
685 | "}}}
686 | " haskell syntax highlighting"{{{
687 | " ---------------------------------------------------------------------
688 | " For use with syntax/haskell.vim : Haskell Syntax File
689 | " http://www.vim.org/scripts/script.php?script_id=3034
690 | " See also Steffen Siering's github repository:
691 | " http://github.com/urso/dotrc/blob/master/vim/syntax/haskell.vim
692 | " ---------------------------------------------------------------------
693 | "
694 | " Treat True and False specially, see the plugin referenced above
695 | let hs_highlight_boolean=1
696 | " highlight delims, see the plugin referenced above
697 | let hs_highlight_delimiters=1
698 | 
699 | exe "hi! cPreCondit". s:fg_orange.s:bg_none   .s:fmt_none
700 | 
701 | exe "hi! VarId"    . s:fg_blue   .s:bg_none   .s:fmt_none
702 | exe "hi! ConId"    . s:fg_yellow .s:bg_none   .s:fmt_none
703 | exe "hi! hsImport" . s:fg_magenta.s:bg_none   .s:fmt_none
704 | exe "hi! hsString" . s:fg_base00 .s:bg_none   .s:fmt_none
705 | 
706 | exe "hi! hsStructure"        . s:fg_cyan   .s:bg_none   .s:fmt_none
707 | exe "hi! hs_hlFunctionName"  . s:fg_blue   .s:bg_none
708 | exe "hi! hsStatement"        . s:fg_cyan   .s:bg_none   .s:fmt_none
709 | exe "hi! hsImportLabel"      . s:fg_cyan   .s:bg_none   .s:fmt_none
710 | exe "hi! hs_OpFunctionName"  . s:fg_yellow .s:bg_none   .s:fmt_none
711 | exe "hi! hs_DeclareFunction" . s:fg_orange .s:bg_none   .s:fmt_none
712 | exe "hi! hsVarSym"           . s:fg_cyan   .s:bg_none   .s:fmt_none
713 | exe "hi! hsType"             . s:fg_yellow .s:bg_none   .s:fmt_none
714 | exe "hi! hsTypedef"          . s:fg_cyan   .s:bg_none   .s:fmt_none
715 | exe "hi! hsModuleName"       . s:fg_green  .s:bg_none   .s:fmt_undr
716 | exe "hi! hsModuleStartLabel" . s:fg_magenta.s:bg_none   .s:fmt_none
717 | hi! link hsImportParams      Delimiter
718 | hi! link hsDelimTypeExport   Delimiter
719 | hi! link hsModuleStartLabel  hsStructure
720 | hi! link hsModuleWhereLabel  hsModuleStartLabel
721 | 
722 | " following is for the haskell-conceal plugin
723 | " the first two items don't have an impact, but better safe
724 | exe "hi! hsNiceOperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
725 | exe "hi! hsniceoperator"     . s:fg_cyan   .s:bg_none   .s:fmt_none
726 | 
727 | "}}}
728 | " pandoc markdown syntax highlighting "{{{
729 | " ---------------------------------------------------------------------
730 | 
731 | "PandocHiLink pandocNormalBlock
732 | exe "hi! pandocTitleBlock"               .s:fg_blue   .s:bg_none   .s:fmt_none
733 | exe "hi! pandocTitleBlockTitle"          .s:fg_blue   .s:bg_none   .s:fmt_bold
734 | exe "hi! pandocTitleComment"             .s:fg_blue   .s:bg_none   .s:fmt_bold
735 | exe "hi! pandocComment"                  .s:fg_base01 .s:bg_none   .s:fmt_ital
736 | exe "hi! pandocVerbatimBlock"            .s:fg_yellow .s:bg_none   .s:fmt_none
737 | hi! link pandocVerbatimBlockDeep         pandocVerbatimBlock
738 | hi! link pandocCodeBlock                 pandocVerbatimBlock
739 | hi! link pandocCodeBlockDelim            pandocVerbatimBlock
740 | exe "hi! pandocBlockQuote"               .s:fg_blue   .s:bg_none   .s:fmt_none
741 | exe "hi! pandocBlockQuoteLeader1"        .s:fg_blue   .s:bg_none   .s:fmt_none
742 | exe "hi! pandocBlockQuoteLeader2"        .s:fg_cyan   .s:bg_none   .s:fmt_none
743 | exe "hi! pandocBlockQuoteLeader3"        .s:fg_yellow .s:bg_none   .s:fmt_none
744 | exe "hi! pandocBlockQuoteLeader4"        .s:fg_red    .s:bg_none   .s:fmt_none
745 | exe "hi! pandocBlockQuoteLeader5"        .s:fg_base0  .s:bg_none   .s:fmt_none
746 | exe "hi! pandocBlockQuoteLeader6"        .s:fg_base01 .s:bg_none   .s:fmt_none
747 | exe "hi! pandocListMarker"               .s:fg_magenta.s:bg_none   .s:fmt_none
748 | exe "hi! pandocListReference"            .s:fg_magenta.s:bg_none   .s:fmt_undr
749 | 
750 | " Definitions
751 | " ---------------------------------------------------------------------
752 | let s:fg_pdef = s:fg_violet
753 | exe "hi! pandocDefinitionBlock"              .s:fg_pdef  .s:bg_none  .s:fmt_none
754 | exe "hi! pandocDefinitionTerm"               .s:fg_pdef  .s:bg_none  .s:fmt_stnd
755 | exe "hi! pandocDefinitionIndctr"             .s:fg_pdef  .s:bg_none  .s:fmt_bold
756 | exe "hi! pandocEmphasisDefinition"           .s:fg_pdef  .s:bg_none  .s:fmt_ital
757 | exe "hi! pandocEmphasisNestedDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bldi
758 | exe "hi! pandocStrongEmphasisDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_bold
759 | exe "hi! pandocStrongEmphasisNestedDefinition"   .s:fg_pdef.s:bg_none.s:fmt_bldi
760 | exe "hi! pandocStrongEmphasisEmphasisDefinition" .s:fg_pdef.s:bg_none.s:fmt_bldi
761 | exe "hi! pandocStrikeoutDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_revr
762 | exe "hi! pandocVerbatimInlineDefinition"     .s:fg_pdef  .s:bg_none  .s:fmt_none
763 | exe "hi! pandocSuperscriptDefinition"        .s:fg_pdef  .s:bg_none  .s:fmt_none
764 | exe "hi! pandocSubscriptDefinition"          .s:fg_pdef  .s:bg_none  .s:fmt_none
765 | 
766 | " Tables
767 | " ---------------------------------------------------------------------
768 | let s:fg_ptable = s:fg_blue
769 | exe "hi! pandocTable"                        .s:fg_ptable.s:bg_none  .s:fmt_none
770 | exe "hi! pandocTableStructure"               .s:fg_ptable.s:bg_none  .s:fmt_none
771 | hi! link pandocTableStructureTop             pandocTableStructre
772 | hi! link pandocTableStructureEnd             pandocTableStructre
773 | exe "hi! pandocTableZebraLight"              .s:fg_ptable.s:bg_base03.s:fmt_none
774 | exe "hi! pandocTableZebraDark"               .s:fg_ptable.s:bg_base02.s:fmt_none
775 | exe "hi! pandocEmphasisTable"                .s:fg_ptable.s:bg_none  .s:fmt_ital
776 | exe "hi! pandocEmphasisNestedTable"          .s:fg_ptable.s:bg_none  .s:fmt_bldi
777 | exe "hi! pandocStrongEmphasisTable"          .s:fg_ptable.s:bg_none  .s:fmt_bold
778 | exe "hi! pandocStrongEmphasisNestedTable"    .s:fg_ptable.s:bg_none  .s:fmt_bldi
779 | exe "hi! pandocStrongEmphasisEmphasisTable"  .s:fg_ptable.s:bg_none  .s:fmt_bldi
780 | exe "hi! pandocStrikeoutTable"               .s:fg_ptable.s:bg_none  .s:fmt_revr
781 | exe "hi! pandocVerbatimInlineTable"          .s:fg_ptable.s:bg_none  .s:fmt_none
782 | exe "hi! pandocSuperscriptTable"             .s:fg_ptable.s:bg_none  .s:fmt_none
783 | exe "hi! pandocSubscriptTable"               .s:fg_ptable.s:bg_none  .s:fmt_none
784 | 
785 | " Headings
786 | " ---------------------------------------------------------------------
787 | let s:fg_phead = s:fg_orange
788 | exe "hi! pandocHeading"                      .s:fg_phead .s:bg_none.s:fmt_bold
789 | exe "hi! pandocHeadingMarker"                .s:fg_yellow.s:bg_none.s:fmt_bold
790 | exe "hi! pandocEmphasisHeading"              .s:fg_phead .s:bg_none.s:fmt_bldi
791 | exe "hi! pandocEmphasisNestedHeading"        .s:fg_phead .s:bg_none.s:fmt_bldi
792 | exe "hi! pandocStrongEmphasisHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
793 | exe "hi! pandocStrongEmphasisNestedHeading"  .s:fg_phead .s:bg_none.s:fmt_bldi
794 | exe "hi! pandocStrongEmphasisEmphasisHeading".s:fg_phead .s:bg_none.s:fmt_bldi
795 | exe "hi! pandocStrikeoutHeading"             .s:fg_phead .s:bg_none.s:fmt_revr
796 | exe "hi! pandocVerbatimInlineHeading"        .s:fg_phead .s:bg_none.s:fmt_bold
797 | exe "hi! pandocSuperscriptHeading"           .s:fg_phead .s:bg_none.s:fmt_bold
798 | exe "hi! pandocSubscriptHeading"             .s:fg_phead .s:bg_none.s:fmt_bold
799 | 
800 | " Links
801 | " ---------------------------------------------------------------------
802 | exe "hi! pandocLinkDelim"                .s:fg_base01 .s:bg_none   .s:fmt_none
803 | exe "hi! pandocLinkLabel"                .s:fg_blue   .s:bg_none   .s:fmt_undr
804 | exe "hi! pandocLinkText"                 .s:fg_blue   .s:bg_none   .s:fmt_undb
805 | exe "hi! pandocLinkURL"                  .s:fg_base00 .s:bg_none   .s:fmt_undr
806 | exe "hi! pandocLinkTitle"                .s:fg_base00 .s:bg_none   .s:fmt_undi
807 | exe "hi! pandocLinkTitleDelim"           .s:fg_base01 .s:bg_none   .s:fmt_undi   .s:sp_base00
808 | exe "hi! pandocLinkDefinition"           .s:fg_cyan   .s:bg_none   .s:fmt_undr   .s:sp_base00
809 | exe "hi! pandocLinkDefinitionID"         .s:fg_blue   .s:bg_none   .s:fmt_bold
810 | exe "hi! pandocImageCaption"             .s:fg_violet .s:bg_none   .s:fmt_undb
811 | exe "hi! pandocFootnoteLink"             .s:fg_green  .s:bg_none   .s:fmt_undr
812 | exe "hi! pandocFootnoteDefLink"          .s:fg_green  .s:bg_none   .s:fmt_bold
813 | exe "hi! pandocFootnoteInline"           .s:fg_green  .s:bg_none   .s:fmt_undb
814 | exe "hi! pandocFootnote"                 .s:fg_green  .s:bg_none   .s:fmt_none
815 | exe "hi! pandocCitationDelim"            .s:fg_magenta.s:bg_none   .s:fmt_none
816 | exe "hi! pandocCitation"                 .s:fg_magenta.s:bg_none   .s:fmt_none
817 | exe "hi! pandocCitationID"               .s:fg_magenta.s:bg_none   .s:fmt_undr
818 | exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
819 | 
820 | " Main Styles
821 | " ---------------------------------------------------------------------
822 | exe "hi! pandocStyleDelim"               .s:fg_base01 .s:bg_none  .s:fmt_none
823 | exe "hi! pandocEmphasis"                 .s:fg_base0  .s:bg_none  .s:fmt_ital
824 | exe "hi! pandocEmphasisNested"           .s:fg_base0  .s:bg_none  .s:fmt_bldi
825 | exe "hi! pandocStrongEmphasis"           .s:fg_base0  .s:bg_none  .s:fmt_bold
826 | exe "hi! pandocStrongEmphasisNested"     .s:fg_base0  .s:bg_none  .s:fmt_bldi
827 | exe "hi! pandocStrongEmphasisEmphasis"   .s:fg_base0  .s:bg_none  .s:fmt_bldi
828 | exe "hi! pandocStrikeout"                .s:fg_base01 .s:bg_none  .s:fmt_revr
829 | exe "hi! pandocVerbatimInline"           .s:fg_yellow .s:bg_none  .s:fmt_none
830 | exe "hi! pandocSuperscript"              .s:fg_violet .s:bg_none  .s:fmt_none
831 | exe "hi! pandocSubscript"                .s:fg_violet .s:bg_none  .s:fmt_none
832 | 
833 | exe "hi! pandocRule"                     .s:fg_blue   .s:bg_none  .s:fmt_bold
834 | exe "hi! pandocRuleLine"                 .s:fg_blue   .s:bg_none  .s:fmt_bold
835 | exe "hi! pandocEscapePair"               .s:fg_red    .s:bg_none  .s:fmt_bold
836 | exe "hi! pandocCitationRef"              .s:fg_magenta.s:bg_none   .s:fmt_none
837 | exe "hi! pandocNonBreakingSpace"         . s:fg_red   .s:bg_none  .s:fmt_revr
838 | hi! link pandocEscapedCharacter          pandocEscapePair
839 | hi! link pandocLineBreak                 pandocEscapePair
840 | 
841 | " Embedded Code
842 | " ---------------------------------------------------------------------
843 | exe "hi! pandocMetadataDelim"            .s:fg_base01 .s:bg_none   .s:fmt_none
844 | exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_none
845 | exe "hi! pandocMetadataKey"              .s:fg_blue   .s:bg_none   .s:fmt_none
846 | exe "hi! pandocMetadata"                 .s:fg_blue   .s:bg_none   .s:fmt_bold
847 | hi! link pandocMetadataTitle             pandocMetadata
848 | 
849 | "}}}
850 | " Utility autocommand "{{{
851 | " ---------------------------------------------------------------------
852 | " In cases where Solarized is initialized inside a terminal vim session and 
853 | " then transferred to a gui session via the command `:gui`, the gui vim process 
854 | " does not re-read the colorscheme (or .vimrc for that matter) so any `has_gui` 
855 | " related code that sets gui specific values isn't executed.
856 | "
857 | " Currently, Solarized sets only the cterm or gui values for the colorscheme 
858 | " depending on gui or terminal mode. It's possible that, if the following 
859 | " autocommand method is deemed excessively poor form, that approach will be 
860 | " used again and the autocommand below will be dropped.
861 | "
862 | " However it seems relatively benign in this case to include the autocommand 
863 | " here. It fires only in cases where vim is transferring from terminal to gui 
864 | " mode (detected with the script scope s:vmode variable). It also allows for 
865 | " other potential terminal customizations that might make gui mode suboptimal.
866 | "
867 | autocmd GUIEnter * if (s:vmode != "gui") | exe "colorscheme " . g:colors_name | endif
868 | "}}}
869 | " Highlight Trailing Space {{{
870 | " Experimental: Different highlight when on cursorline
871 | function! s:SolarizedHiTrail()
872 |     if g:solarized_hitrail==0
873 |         hi! clear solarizedTrailingSpace
874 |     else
875 |         syn match solarizedTrailingSpace "\s*$"
876 |         exe "hi! solarizedTrailingSpace " .s:fmt_undr .s:fg_red .s:bg_none .s:sp_red
877 |     endif
878 | endfunction  
879 | augroup SolarizedHiTrail
880 |     autocmd!
881 |     if g:solarized_hitrail==1
882 |         autocmd! Syntax * call s:SolarizedHiTrail()
883 |         autocmd! ColorScheme * if g:colors_name == "solarized" | call s:SolarizedHiTrail() | else | augroup! s:SolarizedHiTrail | endif
884 |     endif
885 | augroup END
886 | " }}}
887 | " Menus "{{{
888 | " ---------------------------------------------------------------------
889 | " Turn off Solarized menu by including the following assignment in your .vimrc:
890 | "
891 | "    let g:solarized_menu=0
892 | 
893 | function! s:SolarizedOptions()
894 |     new "new buffer
895 |     setf vim "vim filetype
896 |     let failed = append(0, s:defaults_list)
897 |     let failed = append(0, s:colorscheme_list)
898 |     let failed = append(0, s:options_list)
899 |     let failed = append(0, s:lazycat_list)
900 |     0 "jump back to the top
901 | endfunction
902 | if !exists(":SolarizedOptions")
903 |     command SolarizedOptions :call s:SolarizedOptions()
904 | endif
905 | 
906 | function! SolarizedMenu()
907 |     if exists("g:loaded_solarized_menu")
908 |         try
909 |             silent! aunmenu Solarized
910 |         endtry
911 |     endif
912 |     let g:loaded_solarized_menu = 1
913 | 
914 |     if g:colors_name == "solarized" && g:solarized_menu != 0
915 | 
916 |         amenu &Solarized.&Contrast.&Low\ Contrast        :let g:solarized_contrast="low"       \| colorscheme solarized<CR>
917 |         amenu &Solarized.&Contrast.&Normal\ Contrast     :let g:solarized_contrast="normal"    \| colorscheme solarized<CR>
918 |         amenu &Solarized.&Contrast.&High\ Contrast       :let g:solarized_contrast="high"      \| colorscheme solarized<CR>
919 |         an    &Solarized.&Contrast.-sep-                 <Nop>
920 |         amenu &Solarized.&Contrast.&Help:\ Contrast      :help 'solarized_contrast'<CR>
921 | 
922 |         amenu &Solarized.&Visibility.&Low\ Visibility    :let g:solarized_visibility="low"     \| colorscheme solarized<CR>
923 |         amenu &Solarized.&Visibility.&Normal\ Visibility :let g:solarized_visibility="normal"  \| colorscheme solarized<CR>
924 |         amenu &Solarized.&Visibility.&High\ Visibility   :let g:solarized_visibility="high"    \| colorscheme solarized<CR>
925 |         an    &Solarized.&Visibility.-sep-                 <Nop>
926 |         amenu &Solarized.&Visibility.&Help:\ Visibility    :help 'solarized_visibility'<CR>
927 | 
928 |         amenu &Solarized.&Background.&Toggle\ Background :ToggleBG<CR>
929 |         amenu &Solarized.&Background.&Dark\ Background   :set background=dark  \| colorscheme solarized<CR>
930 |         amenu &Solarized.&Background.&Light\ Background  :set background=light \| colorscheme solarized<CR>
931 |         an    &Solarized.&Background.-sep-               <Nop>
932 |         amenu &Solarized.&Background.&Help:\ ToggleBG     :help togglebg<CR>
933 | 
934 |         if g:solarized_bold==0 | let l:boldswitch="On" | else | let l:boldswitch="Off" | endif
935 |         exe "amenu &Solarized.&Styling.&Turn\\ Bold\\ ".l:boldswitch." :let g:solarized_bold=(abs(g:solarized_bold-1)) \\| colorscheme solarized<CR>"
936 |         if g:solarized_italic==0 | let l:italicswitch="On" | else | let l:italicswitch="Off" | endif
937 |         exe "amenu &Solarized.&Styling.&Turn\\ Italic\\ ".l:italicswitch." :let g:solarized_italic=(abs(g:solarized_italic-1)) \\| colorscheme solarized<CR>"
938 |         if g:solarized_underline==0 | let l:underlineswitch="On" | else | let l:underlineswitch="Off" | endif
939 |         exe "amenu &Solarized.&Styling.&Turn\\ Underline\\ ".l:underlineswitch." :let g:solarized_underline=(abs(g:solarized_underline-1)) \\| colorscheme solarized<CR>"
940 | 
941 |         amenu &Solarized.&Diff\ Mode.&Low\ Diff\ Mode    :let g:solarized_diffmode="low"     \| colorscheme solarized<CR>
942 |         amenu &Solarized.&Diff\ Mode.&Normal\ Diff\ Mode :let g:solarized_diffmode="normal"  \| colorscheme solarized<CR>
943 |         amenu &Solarized.&Diff\ Mode.&High\ Diff\ Mode   :let g:solarized_diffmode="high"    \| colorscheme solarized<CR>
944 | 
945 |         if g:solarized_hitrail==0 | let l:hitrailswitch="On" | else | let l:hitrailswitch="Off" | endif
946 |         exe "amenu &Solarized.&Experimental.&Turn\\ Highlight\\ Trailing\\ Spaces\\ ".l:hitrailswitch." :let g:solarized_hitrail=(abs(g:solarized_hitrail-1)) \\| colorscheme solarized<CR>"
947 |         an    &Solarized.&Experimental.-sep-               <Nop>
948 |         amenu &Solarized.&Experimental.&Help:\ HiTrail    :help 'solarized_hitrail'<CR>
949 | 
950 |         an    &Solarized.-sep1-                          <Nop>
951 | 
952 |         amenu &Solarized.&Autogenerate\ options          :SolarizedOptions<CR>
953 | 
954 |         an    &Solarized.-sep2-                          <Nop>
955 | 
956 |         amenu &Solarized.&Help.&Solarized\ Help          :help solarized<CR>
957 |         amenu &Solarized.&Help.&Toggle\ Background\ Help :help togglebg<CR>
958 |         amenu &Solarized.&Help.&Removing\ This\ Menu     :help solarized-menu<CR>
959 | 
960 |         an 9999.77 &Help.&Solarized\ Colorscheme         :help solarized<CR>
961 |         an 9999.78 &Help.&Toggle\ Background             :help togglebg<CR>
962 |         an 9999.79 &Help.-sep3-                          <Nop>
963 | 
964 |     endif
965 | endfunction
966 | 
967 | autocmd ColorScheme * if g:colors_name != "solarized" | silent! aunmenu Solarized | else | call SolarizedMenu() | endif
968 | 
969 | "}}}
970 | " License "{{{
971 | " ---------------------------------------------------------------------
972 | "
973 | " Copyright (c) 2011 Ethan Schoonover
974 | "
975 | " Permission is hereby granted, free of charge, to any person obtaining a copy
976 | " of this software and associated documentation files (the "Software"), to deal
977 | " in the Software without restriction, including without limitation the rights
978 | " to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
979 | " copies of the Software, and to permit persons to whom the Software is
980 | " furnished to do so, subject to the following conditions:
981 | "
982 | " The above copyright notice and this permission notice shall be included in
983 | " all copies or substantial portions of the Software.
984 | "
985 | " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
986 | " IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
987 | " FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
988 | " AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
989 | " LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
990 | " OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
991 | " THE SOFTWARE.
992 | "
993 | " vim:foldmethod=marker:foldlevel=0
994 | "}}}
995 | 


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


--------------------------------------------------------------------------------