├── .gitattributes ├── templates ├── =template=.travis.yml ├── =template=.md ├── =template=.markdown ├── =template=.js └── =template=.html ├── plugins ├── ack.vim ├── template.vim ├── vimfiler.vim ├── split-term.vim ├── emmet.vim ├── xptemplate.vim ├── ale.vim ├── lightline.vim └── startify.vim ├── .gitignore ├── ftplugin └── javascript │ ├── ava.xpt.vim │ ├── assert.xpt.vim │ ├── mocha.xpt.vim │ ├── node.xpt.vim │ ├── js.xpt.vim │ └── es6.xpt.vim ├── oni ├── readme.md └── config.tsx ├── bin └── plug ├── config ├── autocmd.vim ├── plugins.vim └── mappings.vim ├── init.vim ├── vimrc.vim ├── autoload ├── vmf.vim └── plug.vim └── readme.md /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto eol=lf 2 | -------------------------------------------------------------------------------- /templates/=template=.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - "node" 4 | -------------------------------------------------------------------------------- /plugins/ack.vim: -------------------------------------------------------------------------------- 1 | if executable('ag') 2 | let g:ackprg = 'ag --vimgrep' 3 | endif 4 | -------------------------------------------------------------------------------- /plugins/template.vim: -------------------------------------------------------------------------------- 1 | let g:templates_directory = ['~/AppData/Local/nvim/templates'] 2 | -------------------------------------------------------------------------------- /templates/=template=.md: -------------------------------------------------------------------------------- 1 | # %CLASS% 2 | 3 | %HERE% 4 | 5 | --- 6 | 7 | > %LICENSE% 8 | -------------------------------------------------------------------------------- /templates/=template=.markdown: -------------------------------------------------------------------------------- 1 | # %CLASS% 2 | 3 | %HERE% 4 | 5 | --- 6 | 7 | > %LICENSE% 8 | -------------------------------------------------------------------------------- /plugins/vimfiler.vim: -------------------------------------------------------------------------------- 1 | let g:vimfiler_as_default_explorer = 1 2 | let g:vimfiler_tree_leaf_icon = ' ' 3 | let g:vimfiler_tree_opened_icon = '▾' 4 | -------------------------------------------------------------------------------- /templates/=template=.js: -------------------------------------------------------------------------------- 1 | /* {{ license }} */ 2 | 3 | // {{ name }} - {{ filename }} 4 | // 5 | // {{ description }} 6 | // 7 | // {{ mail }} 8 | -------------------------------------------------------------------------------- /plugins/split-term.vim: -------------------------------------------------------------------------------- 1 | " Few configurations variables for https://github.com/vimlab/split-term.vim 2 | 3 | let g:split_term_default_shell = 'bash' 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | bundles/ 2 | node_modules/ 3 | .bundles/ 4 | tags 5 | .init.vim-rplugin* 6 | .netrwhist 7 | yarn-error.log 8 | plugged/ 9 | Session.vim 10 | a.js 11 | -------------------------------------------------------------------------------- /plugins/emmet.vim: -------------------------------------------------------------------------------- 1 | " Emmet global configuration 2 | 3 | let g:user_emmet_install_global = 0 4 | autocmd FileType html,css EmmetInstall 5 | 6 | autocmd FileType html,css imap (emmet-expand-abbr) 7 | -------------------------------------------------------------------------------- /plugins/xptemplate.vim: -------------------------------------------------------------------------------- 1 | " NOTE: You can set this key to , as most users do, for 2 | " convenience. In this case pressing twice results in a normal 3 | " if there is no snippet key matched. 4 | let g:xptemplate_key = '' 5 | -------------------------------------------------------------------------------- /ftplugin/javascript/ava.xpt.vim: -------------------------------------------------------------------------------- 1 | XPTemplate priority=lang-1 2 | 3 | XPT test " ava test 4 | test(`do what^, t => { 5 | `cursor^ 6 | }); 7 | 8 | XPT tp " ava t.plan 9 | t.plan(`how many^); 10 | 11 | XPT ti " ava t.is 12 | t.is(`actual^, `expected^) 13 | -------------------------------------------------------------------------------- /plugins/ale.vim: -------------------------------------------------------------------------------- 1 | " Ale global configuration 2 | 3 | let g:ale_linters = { 4 | \ 'javascript': ['eslint', 'prettier'], 5 | \ 'vim': ['vint'] 6 | \} 7 | 8 | let g:ale_fixers = { 9 | \ 'javascript': ['eslint'] 10 | \} 11 | 12 | " Write this in your vimrc file 13 | let g:ale_lint_on_text_changed = 'never' 14 | -------------------------------------------------------------------------------- /oni/readme.md: -------------------------------------------------------------------------------- 1 | ## Onivim configuration 2 | 3 | Place this file in the appropriate location, refering to 4 | [https://github.com/onivim/oni/wiki/Configuration#configtsx](https://github.com/onivim/oni/wiki/Configuration#configtsx) 5 | 6 | On Windows and my current setup the file is located at `%APPDATA%/Roaming/oni/config.tsx` 7 | -------------------------------------------------------------------------------- /templates/=template=.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | %CLASS% 7 | 8 | 9 | 10 | 11 | 12 | %HERE% 13 | 14 | 15 | -------------------------------------------------------------------------------- /bin/plug: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | 3 | 4 | const dir = `${require('user-home')}/.config/nvim/site/pack`; 5 | const [ repo ] = process.argv.slice(2); 6 | const { exec, spawn } = require('child_process'); 7 | const exists = require('fs').existsSync; 8 | 9 | const giturl = `https://github.com/${repo}.git`; 10 | const destination = `${dir}/${repo.split('/').slice(-1)[0]}`; 11 | exists(destination) || console.log(`${giturl}=> ${destination}`); 12 | exists(destination) || spawn(`git`, `clone ${giturl} ${destination}`.split(' '), { stdio: 'inherit'}); 13 | -------------------------------------------------------------------------------- /ftplugin/javascript/assert.xpt.vim: -------------------------------------------------------------------------------- 1 | XPTemplate priority=lang-1 2 | 3 | XPT asdse " asset.deepStrictEqual 4 | assert.deepStrictEqual(`actual^, `expected^, `message^); 5 | `cursor^ 6 | 7 | XPT ase " assert.equal 8 | assert.equal(`actual^, `expected^, `message^); 9 | `cursor^ 10 | 11 | XPT as " assert 12 | assert(`value^, `message^); 13 | `cursor^ 14 | 15 | XPT asf " assert.fail 16 | assert.fail(`message^); 17 | `cursor^ 18 | 19 | XPT aso " assert.ok 20 | assert.ok(`value^, `message^); 21 | `cursor^ 22 | 23 | XPT asse " assert.strictEqual 24 | assert.strictEqual(`actual^, `expected^, `message^); 25 | `cursor^ 26 | 27 | XPT ast " assert.throws 28 | assert.throws(`fn`) 29 | `cursor^ 30 | -------------------------------------------------------------------------------- /plugins/lightline.vim: -------------------------------------------------------------------------------- 1 | let g:lightline = {} 2 | 3 | let g:lightline.component_expand = { 4 | \ 'linter_checking': 'lightline#ale#checking', 5 | \ 'linter_warnings': 'lightline#ale#warnings', 6 | \ 'linter_errors': 'lightline#ale#errors', 7 | \ 'linter_ok': 'lightline#ale#ok', 8 | \ } 9 | 10 | " Set color to the components: 11 | let g:lightline.component_type = { 12 | \ 'linter_checking': 'left', 13 | \ 'linter_warnings': 'warning', 14 | \ 'linter_errors': 'error', 15 | \ 'linter_ok': 'left', 16 | \ } 17 | 18 | " Add the components to the lightline, for example to the right side: 19 | let g:lightline.active = { 'right': [[ 'linter_checking', 'linter_errors', 'linter_warnings', 'linter_ok' ]] } 20 | -------------------------------------------------------------------------------- /ftplugin/javascript/mocha.xpt.vim: -------------------------------------------------------------------------------- 1 | 2 | " Thanks to Torgeir Thoresen vim personal files 3 | " 4 | " https://github.com/torgeir/vim/blob/master/snippets/ftplugin/javascript/javascript.xpt.vim 5 | 6 | XPTemplate priority=lang-1 7 | 8 | XPT after " js bdd after 9 | after((`done^) => { 10 | `cursor^ 11 | }); 12 | 13 | 14 | XPT before " js bdd before 15 | before((`done^) => { 16 | `cursor^ 17 | }); 18 | 19 | 20 | XPT desc " js bdd describe 21 | describe('`a piece of functionality^', () => { 22 | `cursor^ 23 | }); 24 | 25 | XPT describe " js bdd describe 26 | describe('`a piece of functionality^', () => { 27 | `cursor^ 28 | }); 29 | 30 | XPT it " js bdd it 31 | it('`does what^', (`done^) => { 32 | `cursor^ 33 | }); 34 | 35 | XPT itp " js bdd pending it 36 | it('`does what^'); 37 | -------------------------------------------------------------------------------- /config/autocmd.vim: -------------------------------------------------------------------------------- 1 | " Autocommand config 2 | " 3 | 4 | " Remember last location in file 5 | au BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") 6 | \| exe "normal g'\"" | endif 7 | 8 | " remove any trailing whitespace on file save. 9 | au BufWrite * if ! &bin | silent! %s/\s\+$//ge | endif 10 | 11 | " always set fileformat=unix 12 | au BufWrite * set fileformat=unix 13 | 14 | " Thorfile, Rakefile, Vagrantfile and Gemfile are Ruby 15 | au BufRead,BufNewFile {Gemfile,Rakefile,Vagrantfile,Thorfile,config.ru} set ft=ruby 16 | 17 | " autocmd VimEnter * if !argc() | VimFilerExplorer -status -winwidth=30 | endif 18 | " Make Click and expand the dir instead of cding into it 19 | autocmd FileType vimfiler nmap <2-LeftMouse> (vimfiler_smart_l) 20 | autocmd FileType vimfiler nmap (vimfiler_smart_l) 21 | 22 | -------------------------------------------------------------------------------- /ftplugin/javascript/node.xpt.vim: -------------------------------------------------------------------------------- 1 | " Thanks to Torgeir Thoresen vim personal files 2 | " 3 | " https://github.com/torgeir/vim/blob/master/snippets/ftplugin/javascript/javascript.xpt.vim 4 | 5 | XPTemplate priority=lang-1 6 | 7 | let s:f = g:XPTfuncs() 8 | 9 | " strip directory portion of a pathname 10 | function! s:f.strip_path(pathname) 11 | if has('win32') 12 | return substitute(system("node -pe \"require('path').basename('" . shellescape(a:pathname) . "')"), "\n", "", 'g') 13 | else 14 | return substitute(system("basename " . shellescape(a:pathname)), "\n", "", 'g') 15 | endif 16 | endfunction 17 | 18 | " camel cases words separated by - 19 | function! s:f.camelize(str) 20 | return substitute(a:str, '[.-]\(\w*\)', '\u\1', 'g') 21 | endfunction 22 | 23 | XPT req " node require module 24 | const `module^camelize(strip_path(V()))^ = require('``module^'); 25 | -------------------------------------------------------------------------------- /ftplugin/javascript/js.xpt.vim: -------------------------------------------------------------------------------- 1 | " Thanks to Torgeir Thoresen vim personal files 2 | " 3 | " https://github.com/torgeir/vim/blob/master/snippets/ftplugin/javascript/javascript.xpt.vim 4 | 5 | XPTemplate priority=lang-1 6 | 7 | XPT : " js key:value pair 8 | `key^: `value^`...^, 9 | `key^: `value^`...^ 10 | 11 | 12 | XPT info " js console.info 13 | console.info(`cursor^); 14 | 15 | 16 | XPT log " js console.log 17 | console.log(`cursor^); 18 | 19 | XPT l " js console.log 20 | console.log(`cursor^); 21 | 22 | 23 | XPT warn " js console.warn 24 | console.warn(`cursor^); 25 | 26 | 27 | XPT error " js console.err 28 | console.error(`cursor^); 29 | 30 | 31 | XPT ex " js bdd expect 32 | expect(`obj^).to`Equal^(`^); 33 | 34 | XPT jsdoc " js doc comment 35 | /** 36 | * `Block description^ 37 | * 38 | * @param {`type^} `name^ - `parameter description^`...^ 39 | * @param {`type^} `name^ - `parameter description^`...^ 40 | */ 41 | -------------------------------------------------------------------------------- /ftplugin/javascript/es6.xpt.vim: -------------------------------------------------------------------------------- 1 | XPTemplate priority=lang-1 2 | 3 | XPT fun " es6 function 4 | const `name^ = () => { 5 | `cursor^ 6 | }; 7 | 8 | XPT setTimeout " setTimeout\(\() => { .. }, ..) 9 | setTimeout(() => `do what^, `milliseconds^); 10 | `cursor^ 11 | 12 | XPT () " es6 arrow function 13 | () => { 14 | `cursor^ 15 | } 16 | 17 | XPT new " const .. = new ..\(..) 18 | XSET arg*|post=ExpandIfNotEmpty(', ', 'arg*') 19 | const `name^ = new `Constructor^(`arg*^) 20 | `cursor^ 21 | 22 | XPT class " class es6 skeleton 23 | XSET arg*|post=ExpandIfNotEmpty(', ', 'arg*') 24 | class `name^ { 25 | constructor(`arg*^) { 26 | `cursor^ 27 | } 28 | } 29 | 30 | XPT cm " class es6 method 31 | `methodName^() { 32 | `cursor^ 33 | } 34 | 35 | XPT im "es6 import 36 | import `what^ from `where^; 37 | `cursor^ 38 | 39 | XPT ex "es6 export 40 | export `default^ `what^ 41 | 42 | XPT p " es6 promise 43 | new Promise((resolve, reject) => { 44 | `cursor^ 45 | }); 46 | 47 | XPT forof " es6 for of 48 | for (const `item^ of `items^) { 49 | `cursor^ 50 | } 51 | -------------------------------------------------------------------------------- /init.vim: -------------------------------------------------------------------------------- 1 | set nocompatible 2 | 3 | if has('win32') 4 | so ~/AppData/Local/nvim/vimrc.vim 5 | so ~/AppData/Local/nvim/config/plugins.vim 6 | so ~/AppData/Local/nvim/config/autocmd.vim 7 | so ~/AppData/Local/nvim/plugins/emmet.vim 8 | so ~/AppData/Local/nvim/plugins/vimfiler.vim 9 | so ~/AppData/Local/nvim/plugins/startify.vim 10 | so ~/AppData/Local/nvim/plugins/ack.vim 11 | so ~/AppData/Local/nvim/plugins/ale.vim 12 | so ~/AppData/Local/nvim/plugins/lightline.vim 13 | so ~/AppData/Local/nvim/plugins/split-term.vim 14 | so ~/AppData/Local/nvim/plugins/xptemplate.vim 15 | so ~/AppData/Local/nvim/plugins/template.vim 16 | so ~/AppData/Local/nvim/config/mappings.vim 17 | else 18 | so ~/.config/nvim/vimrc.vim 19 | so ~/.config/nvim/config/plugins.vim 20 | so ~/.config/nvim/config/autocmd.vim 21 | so ~/.config/nvim/plugins/emmet.vim 22 | so ~/.config/nvim/plugins/vimfiler.vim 23 | so ~/.config/nvim/plugins/startify.vim 24 | so ~/.config/nvim/plugins/ack.vim 25 | so ~/.config/nvim/plugins/ale.vim 26 | so ~/.config/nvim/plugins/lightline.vim 27 | so ~/.config/nvim/plugins/split-term.vim 28 | so ~/.config/nvim/plugins/xptemplate.vim 29 | so ~/.config/nvim/plugins/template.vim 30 | so ~/.config/nvim/config/mappings.vim 31 | end 32 | -------------------------------------------------------------------------------- /plugins/startify.vim: -------------------------------------------------------------------------------- 1 | let g:startify_list_order = [ 2 | \ [' >> Bookmarks'], 'bookmarks', 3 | \ [' >> Sessions'], 'sessions', 4 | \ [' >> Most recently used files in cwd (mru)'], 'dir', 5 | \ [' >> Most recently used files (mru)'], 'files', 6 | \ ] 7 | 8 | let g:startify_bookmarks = systemlist( 9 | \ "node -e \"path = require('path');" 10 | \ . "fs = require('fs');" 11 | \ . "HOME = process.env.USERPROFILE || process.env.HOME; " 12 | \ . "try {" 13 | \ . " files = fs.readdirSync(path.join(HOME, 'dev')); " 14 | \ . " files = files.map(dir => path.join(HOME, 'dev', dir)); " 15 | \ . " files = files.map(dir => ({ dir, stat: fs.statSync(dir) })); " 16 | \ . " files = files.filter(dir => dir.stat.isDirectory());" 17 | \ . " files = files.filter(dir => !dir.dir.includes('Recycle.Bin'));" 18 | \ . " files = files.map(dir => dir.dir);" 19 | \ . " files = files.map(dir => dir.replace(HOME, '~'));" 20 | \ . " console.log(files.join('\\n'));" 21 | \ . "} catch(e) {}" 22 | \ . "\"") 23 | 24 | hi StartifyBracket ctermfg=240 25 | hi StartifyFile ctermfg=147 26 | hi StartifyFooter ctermfg=240 27 | hi StartifyHeader ctermfg=114 28 | hi StartifyNumber ctermfg=215 29 | hi StartifyPath ctermfg=245 30 | hi StartifySlash ctermfg=240 31 | hi StartifySpecial ctermfg=240 32 | -------------------------------------------------------------------------------- /config/plugins.vim: -------------------------------------------------------------------------------- 1 | call plug#begin() 2 | 3 | " Filer 4 | Plug 'Shougo/unite.vim' 5 | Plug 'Shougo/unite-outline' 6 | Plug 'Shougo/vimfiler.vim' 7 | 8 | Plug 'ctrlpvim/ctrlp.vim' 9 | 10 | " Syntax 11 | Plug 'pangloss/vim-javascript' 12 | 13 | " Status bar 14 | Plug 'itchyny/lightline.vim' 15 | Plug 'maximbaz/lightline-ale' 16 | 17 | " Git 18 | Plug 'mhinz/vim-signify' 19 | Plug 'jreybert/vimagit' 20 | 21 | " Syntax 22 | Plug 'tpope/vim-markdown' 23 | Plug 'tpope/vim-cucumber' 24 | Plug 'nono/vim-handlebars' 25 | 26 | " Theme 27 | Plug 'arcticicestudio/nord-vim' 28 | 29 | " Lint 30 | Plug 'w0rp/ale', { 'do': 'npm install --loglevel notice -g eslint jsonlint prettier' } 31 | 32 | " Terminal 33 | Plug '~/dev/split-term.vim' 34 | " Plug 'vimlab/split-term.vim' 35 | 36 | " Snippets 37 | Plug 'drmingdrmer/xptemplate' 38 | 39 | " Templates 40 | Plug 'aperezdc/vim-template' 41 | 42 | " FileSystem 43 | Plug 'tpope/vim-eunuch' 44 | 45 | " Session 46 | Plug 'tpope/vim-obsession' 47 | 48 | " Layout / Windows Managemenr 49 | Plug 'wesQ3/vim-windowswap' 50 | 51 | " API Blueprint 52 | Plug 'kylef/apiblueprint.vim' 53 | 54 | " Misc 55 | Plug 'mileszs/ack.vim' 56 | Plug 'godlygeek/tabular' 57 | Plug 'tomtom/tcomment_vim' 58 | Plug 'ryanoasis/vim-devicons' 59 | Plug 'mattn/emmet-vim' 60 | Plug 'moll/vim-node' 61 | Plug 'tpope/vim-dispatch' 62 | Plug 'terryma/vim-multiple-cursors' 63 | 64 | Plug 'mhinz/vim-startify' 65 | 66 | call plug#end() 67 | -------------------------------------------------------------------------------- /oni/config.tsx: -------------------------------------------------------------------------------- 1 | const activate = oni => { 2 | const isMode = mode => { 3 | const isMenuOpen = oni.menu.isMenuOpen(); 4 | const editorMode = oni.editors.activeEditor.mode; 5 | return mode === 'menu' ? isMenuOpen : editorMode === mode; 6 | }; 7 | 8 | const commandMode = () => isMode('cmdline_normal'); 9 | 10 | // Panes 11 | oni.input.bind('', 'markdown.togglePreview'); 12 | oni.input.bind('', 'sidebar.toggle'); 13 | 14 | // Command-line 15 | oni.input.bind('', 'editor.clipboard.paste', commandMode); 16 | }; 17 | 18 | module.exports = { 19 | activate, 20 | 'ui.colorscheme': 'nord', 21 | 'oni.loadInitVim': true, 22 | 'oni.useDefaultConfig': false, 23 | 'editor.fontSize': '14px', 24 | 25 | // UI customizations 26 | 'ui.animations.enabled': true, 27 | 'ui.fontSmoothing': 'auto', 28 | 29 | 'snippets.enabled': false, 30 | 31 | 'sidebar.plugins.enabled': true, 32 | 33 | // Oni's clipboard-manager adds bugs and yields no benefits 34 | 'editor.clipboard.enabled': false, 35 | 36 | 'oni.plugins.prettier': { 37 | settings: { 38 | semi: true, 39 | tabWidth: 2, 40 | useTabs: false, 41 | singleQuote: true, 42 | trailingComma: 'none', 43 | bracketSpacing: true, 44 | jsxBracketSameLine: false, 45 | arrowParens: 'avoid', 46 | printWidth: 80 47 | }, 48 | 49 | // TODO: Set this to true to enable formatting on save 50 | formatOnSave: false, 51 | 52 | // TODO: Set this to true to enable the plugin 53 | enabled: true 54 | }, 55 | 56 | // Experimental features 57 | 'editor.quickInfo.delay': 100, 58 | 'sidebar.marks.enabled': true, 59 | 'experimental.markdownPreview.enabled': true 60 | }; 61 | -------------------------------------------------------------------------------- /config/mappings.vim: -------------------------------------------------------------------------------- 1 | " Mappings 2 | 3 | " key set to , 4 | let mapleader=',' 5 | let maplocalleader=' ' 6 | 7 | " Tab switch 8 | nmap :tabprevious 9 | nmap :tabnext 10 | 11 | " Buffer switch 12 | nmap :tabprevious 13 | nmap :tabnext 14 | nmap :bprev 15 | nmap :bnext 16 | 17 | " Ctrl+arrow keys to switch between window 18 | nmap :wincmd h 19 | nmap :wincmd l 20 | nmap :wincmd j 21 | nmap :wincmd k 22 | 23 | " Same for hjkl 24 | nmap :wincmd h 25 | nmap :wincmd l 26 | nmap :wincmd j 27 | nmap :wincmd k 28 | 29 | " Open tab with Ctrl+T 30 | nmap :tabnew 31 | 32 | " Browser like Ctrl-W to close current bufffer and remove it from the list 33 | " nmap :bd 34 | 35 | " ",," to switch to previous edited buffer 36 | nmap :b# 37 | 38 | " `tt` in normal mode to toggle comments 39 | noremap tt :TComment 40 | 41 | " Filer 42 | nmap n :VimFilerExplorer -parent -no-focus -status -winwidth=30 43 | nmap b :VimFiler 44 | 45 | " ALE 46 | nmap f (ale_fix) 47 | 48 | " CtrlP 49 | nmap :CtrlPBuffer 50 | if !exists('g:gui_oni') 51 | nmap :CtrlP 52 | endif 53 | 54 | -------------------------------------------------------------------------------- /vimrc.vim: -------------------------------------------------------------------------------- 1 | " General configuration 2 | " load the plugin and indent settings for the detected filetype 3 | 4 | filetype plugin indent on 5 | 6 | set splitright 7 | 8 | " show line numbers 9 | set number 10 | 11 | " show line and column number 12 | set ruler 13 | 14 | syntax enable 15 | 16 | " keep curent color settings 17 | syntax on 18 | 19 | " Use modeline overrides 20 | set modeline 21 | set modelines=10 22 | 23 | " no fold by default 24 | set nofoldenable 25 | 26 | " No Backup! Yeah. COMMIT EVERYTHING 27 | set nobackup 28 | set noswapfile 29 | 30 | " Set encoding 31 | set encoding=utf-8 32 | 33 | " Whitespace stuff 34 | set nowrap 35 | set tabstop=2 36 | set shiftwidth=2 37 | set softtabstop=2 38 | set expandtab 39 | set list listchars=tab:\ \ ,trail:· 40 | 41 | " Searching 42 | set nohlsearch 43 | set incsearch 44 | set ignorecase 45 | set smartcase 46 | 47 | " Tab completion 48 | set wildmode=list:longest,list:full 49 | set wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/* 50 | " disable preview window in completions 51 | set completeopt=menu 52 | 53 | " Status bar 54 | set laststatus=2 55 | 56 | " Splitting a window reduce the size of the current window and leave the other 57 | " windows the same 58 | set noequalalways 59 | 60 | " Show (partial) command in the status line 61 | set showcmd 62 | 63 | " allow backspacing over everything in insert mode 64 | set backspace=indent,eol,start 65 | 66 | if &termencoding == "" 67 | let &termencoding = &encoding 68 | endif 69 | 70 | set encoding=utf-8 71 | setglobal fileencoding=utf-8 72 | set fileencodings=ucs-bom,utf-8,latin1 73 | 74 | " use the clipboard for ALL operations (as opposed to interacting with the '+' 75 | " and/or '*' registers explicitly) 76 | set clipboard+=unnamedplus 77 | 78 | " Always splitbelow 79 | set splitbelow 80 | 81 | " let g:vimfiler_tree_closed_icon = 'aa' 82 | 83 | " Theme / Colorsheme configuration 84 | 85 | " scheme 86 | " colorscheme slate 87 | 88 | " terminal should support 256 colors 89 | set t_Co=256 90 | 91 | let g:airline_powerline_fonts = 1 92 | set guifont=Droid\ Sans\ Mono\ for\ Powerline\ Nerd\ Font\ Complete\ 12 93 | let $NVIM_TUI_ENABLE_TRUE_COLOR=1 94 | -------------------------------------------------------------------------------- /autoload/vmf.vim: -------------------------------------------------------------------------------- 1 | " vimfiles: higher lvl api / commands to vim-plug 2 | " =============================================== 3 | 4 | if exists('g:loaded_vimfiles') 5 | " finish 6 | endif 7 | let g:loaded_vimfiles = 1 8 | 9 | let g:VIMFILES_SEP = has('win32') ? '\' : '/' 10 | let g:VIMFILES_DIR = join([$HOME, has('win32') ? 'vimfiles' : '.vim'], g:VIMFILES_SEP) 11 | let g:VIMFILES_HIGROUP = 'Comment' 12 | let s:begin = 0 13 | 14 | function! vmf#join(...) 15 | let list = a:000 16 | let value = join(list, '/') 17 | 18 | " clean up windows \ separator 19 | let value = substitute(value, '\', '/', 'g') 20 | 21 | " cleanup any consecutive slash 22 | let value = substitute(value, '/\+', '/', 'g') 23 | 24 | " lastly, return the correct platform specific path 25 | return substitute(value, '/', has('win32') ? '\' : '/', 'g') 26 | endfunction 27 | 28 | function! vmf#glob(pattern) 29 | return split(glob(a:pattern), '\n') 30 | endfunction 31 | 32 | function! vmf#source(pattern) 33 | let path = vmf#join(g:VIMFILES_DIR, a:pattern) 34 | for file in vmf#glob(path) 35 | call vmf#log('Comment', 'Source', file) 36 | exe "source " . file 37 | endfor 38 | endfunction 39 | 40 | let s:logs = [] 41 | function! vmf#log(group, ...) 42 | let msg = join(a:000, ' ') 43 | call add(s:logs, { 'group': a:group, 'msg': 'Vimfiles: ' . msg }) 44 | endfunction 45 | 46 | function! vmf#logs() 47 | return s:logs 48 | endfunction 49 | 50 | function! vmf#clear() 51 | let s:logs = [] 52 | return s:logs 53 | endfunction 54 | 55 | function! vmf#debug(group, ...) 56 | let msg = join(a:000, ' ') 57 | echohl a:group | echomsg msg | echohl None 58 | endfunction 59 | 60 | function! vmf#end() 61 | call vmf#log('Todo', 'Calling plug#end') 62 | call plug#end() 63 | endfunction 64 | 65 | function! s:Vimfiles(pattern) 66 | call vmf#source(a:pattern) 67 | endfunction 68 | 69 | function! s:Vimfile(repo) 70 | if s:begin == 0 71 | call vmf#log('Todo', 'Calling plug#begin() with ' . g:VIMFILES_BUNDLES) 72 | call plug#begin(g:VIMFILES_BUNDLES) 73 | let s:begin = 1 74 | endif 75 | 76 | call vmf#log('String', 'Plug ' . a:repo) 77 | Plug a:repo 78 | endfunction 79 | 80 | function! s:Vmfrc() 81 | exe "edit " . vmf#join('~', has('win32') ? 'vimfiles' : '.vim', 'vimrc') 82 | endfunction 83 | 84 | function! s:Messages() 85 | for log in s:logs 86 | call vmf#debug(log.group, log.msg) 87 | endfor 88 | endfunction 89 | 90 | command! -nargs=+ Vimfiles call s:Vimfiles() 91 | command! -nargs=+ Vimfile call s:Vimfile() 92 | 93 | command! Vmfrc call s:Vmfrc() 94 | command! VmfMsg call s:Messages() 95 | command! VmfMessages call s:Messages() 96 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # vimfiles 2 | 3 | This is my cross-platform, cross-editor `~/.vim` folder. 4 | 5 | That being said, this repo is now tailored to work best with [Onivim](https://www.onivim.io). 6 | 7 | ## Description 8 | 9 | - Works well on unix, and pretty fine on Windows 10 | - Small set of [plugins](#plugins) for general development 11 | - Modular nvim / vim and common [configuration](#configuration). Plugins' 12 | configurations are loaded from their respective files. 13 | 14 | Here is how it looks with [Onivim](https://www.onivim.io) on Windows 10 and 15 | [Windows Subsystem for 16 | Linux](https://docs.microsoft.com/fr-fr/windows/wsl/about). 17 | 18 | ![onivim](https://user-images.githubusercontent.com/113832/46247500-926bf380-c40c-11e8-882b-8769a523a532.png) 19 | 20 | ## Installation 21 | 22 | Using Neovim: Clone to `~/.config/nvim`. 23 | ```sh 24 | # osx / nix 25 | $ git clone https://github.com/mklabs/vimfiles.git ~/.config/nvim 26 | ``` 27 | 28 | Using vim: Clone to `~/vimfiles` on windows, clone to `~/.vim` everywhere else. 29 | 30 | Using onivim: Clone to `~/AppData/Local/nvim` on windows, and ignore the following Windows note. 31 | 32 | **Windows Note**: You need to rename the ~/.vimrc to its windows equivalent 33 | `~/_vimrc` & `~/_gvimrc` (a `_` instead of `.`). The colorscheme is left to 34 | default and can be configured in `_vimrc` file. 35 | 36 | **Fonts note**: In order for vim-devicons to work, you'll need to install 37 | [Droid sans Mono nerd 38 | font](https://github.com/ryanoasis/nerd-fonts#font-installation) and run `sudo fc-cache -f -v` (tested on Ubuntu) 39 | 40 | ### Plugin install 41 | 42 | Once vim is started, run `:PlugInstall` or `:PlugUpdate`. 43 | 44 | ## Plugins 45 | 46 | See [`config/plugins.vim`](./config/plugins.vim) to configure the list of plugins to install. 47 | 48 | ## Configuration 49 | 50 | ### vimrc 51 | 52 | `init.vim` is just a symlink to `vimrc`. The first is used by neovim while the 53 | latter is used by regular vim. 54 | 55 | Common plugin and configurations are loaded with from within 56 | [`./config`](./config) folder. 57 | 58 | Default themse set to [Oceanic Next][] only for unix terminal or GUI environment. 59 | 60 | #### ./config 61 | 62 | - plugins.vim - vim-plug initialization and definitions of plugins used 63 | - mappings.vim - contains most of the general keybindings (not plugin specific) 64 | - autocmd.vim - Autocommand stuff to hook certain action on particular Vim events 65 | 66 | #### ./plugins 67 | 68 | - {pluginName}.vim - contains plugin specific configuration and mappings 69 | 70 | #### Mappings 71 | 72 | These mappings have been thought to work alongside Onivim's default one. 73 | 74 | | Mapping | Description | 75 | | --------- | ------------- | 76 | | , | Map Leader | 77 | | Shift Up | Previous tab | 78 | | Shift Down | Next Tab | 79 | | Shift Left | Previous Tab | 80 | | Shift Right | Next Tab | 81 | | Shift h | Previous buffer | 82 | | Shift l | Next buffer | 83 | | Ctrl Left, Ctrl h | Navigate to left window | 84 | | Ctrl Right, Ctrl l | Navigate to right window | 85 | | Ctrl Down, Ctrl j | Navigate to bottom window | 86 | | Ctrl Up, Ctrl k | Navigate to upper window | 87 | | Ctrl o | New tab | 88 | | ,, | Previous edited buffer | 89 | | tt | Toggle comments | 90 | | ,n | Opens VimFiler Explorer mode | 91 | | ,b | Opens VimFiler in current buffer | 92 | | Ctrl b | Opens CtrlPBuffer | 93 | | Tab (in insert mode) | Triggers emmet expand (when appropriate) | 94 | | ,f | Apply ALEFix with prettier (through eslint) | 95 | 96 | ## Snippets 97 | 98 | Snippets are enabled and provided by [xptemplate](https://github.com/drmingdrmer/xptemplate). 99 | 100 | The `ftplugin/*/*.xpt.vim` files are actually snippet definition files for 101 | xptemplate. Feel free to browse them or edit them in your own fork. 102 | 103 | In this repository, they're written using two-spaces indent with semi-colon. 104 | Though it can be easily fixed after being replaced with tools like 105 | [prettier](https://github.com/prettier/prettier) 106 | 107 | Some snippets don't have semi colons as they are designed to be use, in some 108 | place, where semi-colons are not desired. Such as `()` which expands to 109 | anonymous arrow functions. 110 | 111 | Right now, there's quite a few snippets tailored for JavaScript development 112 | using es6 syntax and mocha definitions. 113 | 114 | Also, huhe thanks to [torgeir/vim](https://github.com/torgeir/vim) for the 115 | `req` snippet, which replace and strip down the basename part of the required 116 | module. In addition to that, quite a few snippet (namely for mocha) have been 117 | borrowed from his repository. 118 | 119 | ## Templates 120 | 121 | Templates are enabled and provided by [vim-template](https://github.com/aperezdc/vim-template). 122 | 123 | > This is a simple plug-in for Vim (and NeoVim) allowing to have template 124 | files per file type, which will be used as starting point when creating 125 | new buffers. Template files may contain variables (|template-variables|), 126 | which are expanded at the time of buffer creation (see |template-usage|). 127 | The main purpose of the templates is to add boilerplate code to new 128 | files, like C/C++ header guards, or license disclaimers. 129 | 130 | Few templates are defined in this repository, in the [./templates](./templates) 131 | directory. 132 | 133 | ## Credits 134 | 135 | It started as a fork of [quick-vim][], but have diverged quite a bit. 136 | 137 | vim/gvim config files based on [janus][] config. A good amount of vim goodies 138 | were also taken from Derek's [vim-config][] 139 | 140 | **Thanks**: [quick-vim][], [vim-config][], [janus][], [nvie's vimrc][] 141 | 142 | [vim-config]: https://github.com/derekwyatt/vim-config/ 143 | [janus]: http://github.com/carlhuda/janus 144 | [quick-vim]: https://github.com/brianleroux/quick-vim/ 145 | [nvie's vimrc]: https://github.com/nvie/vimrc 146 | -------------------------------------------------------------------------------- /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 ``-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') || has('win64') 100 | let s:nvim = has('nvim-0.2') || (has('nvim') && exists('*jobwait') && !s:is_win) 101 | let s:vim8 = has('patch-8.0.0039') && exists('*job_start') 102 | let s:me = resolve(expand(':p')) 103 | let s:base_spec = { 'branch': 'master', 'frozen': 0 } 104 | let s:TYPE = { 105 | \ 'string': type(''), 106 | \ 'list': type([]), 107 | \ 'dict': type({}), 108 | \ 'funcref': type(function('call')) 109 | \ } 110 | let s:loaded = get(s:, 'loaded', {}) 111 | let s:triggers = get(s:, 'triggers', {}) 112 | 113 | function! plug#begin(...) 114 | if a:0 > 0 115 | let s:plug_home_org = a:1 116 | let home = s:path(fnamemodify(expand(a:1), ':p')) 117 | elseif exists('g:plug_home') 118 | let home = s:path(g:plug_home) 119 | elseif !empty(&rtp) 120 | let home = s:path(split(&rtp, ',')[0]) . '/plugged' 121 | else 122 | return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.') 123 | endif 124 | if fnamemodify(home, ':t') ==# 'plugin' && fnamemodify(home, ':h') ==# s:first_rtp 125 | return s:err('Invalid plug home. '.home.' is a standard Vim runtime path and is not allowed.') 126 | endif 127 | 128 | let g:plug_home = home 129 | let g:plugs = {} 130 | let g:plugs_order = [] 131 | let s:triggers = {} 132 | 133 | call s:define_commands() 134 | return 1 135 | endfunction 136 | 137 | function! s:define_commands() 138 | command! -nargs=+ -bar Plug call plug#() 139 | if !executable('git') 140 | return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.') 141 | endif 142 | command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(0, []) 143 | command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate call s:update(0, []) 144 | command! -nargs=0 -bar -bang PlugClean call s:clean(0) 145 | command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif 146 | command! -nargs=0 -bar PlugStatus call s:status() 147 | command! -nargs=0 -bar PlugDiff call s:diff() 148 | command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(0, ) 149 | endfunction 150 | 151 | function! s:to_a(v) 152 | return type(a:v) == s:TYPE.list ? a:v : [a:v] 153 | endfunction 154 | 155 | function! s:to_s(v) 156 | return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n" 157 | endfunction 158 | 159 | function! s:glob(from, pattern) 160 | return s:lines(globpath(a:from, a:pattern)) 161 | endfunction 162 | 163 | function! s:source(from, ...) 164 | let found = 0 165 | for pattern in a:000 166 | for vim in s:glob(a:from, pattern) 167 | execute 'source' s:esc(vim) 168 | let found = 1 169 | endfor 170 | endfor 171 | return found 172 | endfunction 173 | 174 | function! s:assoc(dict, key, val) 175 | let a:dict[a:key] = add(get(a:dict, a:key, []), a:val) 176 | endfunction 177 | 178 | function! s:ask(message, ...) 179 | call inputsave() 180 | echohl WarningMsg 181 | let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) ')) 182 | echohl None 183 | call inputrestore() 184 | echo "\r" 185 | return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0 186 | endfunction 187 | 188 | function! s:ask_no_interrupt(...) 189 | try 190 | return call('s:ask', a:000) 191 | catch 192 | return 0 193 | endtry 194 | endfunction 195 | 196 | function! plug#end() 197 | if !exists('g:plugs') 198 | return s:err('Call plug#begin() first') 199 | endif 200 | 201 | if exists('#PlugLOD') 202 | augroup PlugLOD 203 | autocmd! 204 | augroup END 205 | augroup! PlugLOD 206 | endif 207 | let lod = { 'ft': {}, 'map': {}, 'cmd': {} } 208 | 209 | if exists('g:did_load_filetypes') 210 | filetype off 211 | endif 212 | for name in g:plugs_order 213 | if !has_key(g:plugs, name) 214 | continue 215 | endif 216 | let plug = g:plugs[name] 217 | if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') 218 | let s:loaded[name] = 1 219 | continue 220 | endif 221 | 222 | if has_key(plug, 'on') 223 | let s:triggers[name] = { 'map': [], 'cmd': [] } 224 | for cmd in s:to_a(plug.on) 225 | if cmd =~? '^.\+' 226 | if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i')) 227 | call s:assoc(lod.map, cmd, name) 228 | endif 229 | call add(s:triggers[name].map, cmd) 230 | elseif cmd =~# '^[A-Z]' 231 | let cmd = substitute(cmd, '!*$', '', '') 232 | if exists(':'.cmd) != 2 233 | call s:assoc(lod.cmd, cmd, name) 234 | endif 235 | call add(s:triggers[name].cmd, cmd) 236 | else 237 | call s:err('Invalid `on` option: '.cmd. 238 | \ '. Should start with an uppercase letter or ``.') 239 | endif 240 | endfor 241 | endif 242 | 243 | if has_key(plug, 'for') 244 | let types = s:to_a(plug.for) 245 | if !empty(types) 246 | augroup filetypedetect 247 | call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim') 248 | augroup END 249 | endif 250 | for type in types 251 | call s:assoc(lod.ft, type, name) 252 | endfor 253 | endif 254 | endfor 255 | 256 | for [cmd, names] in items(lod.cmd) 257 | execute printf( 258 | \ 'command! -nargs=* -range -bang -complete=file %s call s:lod_cmd(%s, "", , , , %s)', 259 | \ cmd, string(cmd), string(names)) 260 | endfor 261 | 262 | for [map, names] in items(lod.map) 263 | for [mode, map_prefix, key_prefix] in 264 | \ [['i', '', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']] 265 | execute printf( 266 | \ '%snoremap %s %s:call lod_map(%s, %s, %s, "%s")', 267 | \ mode, map, map_prefix, string(map), string(names), mode != 'i', key_prefix) 268 | endfor 269 | endfor 270 | 271 | for [ft, names] in items(lod.ft) 272 | augroup PlugLOD 273 | execute printf('autocmd FileType %s call lod_ft(%s, %s)', 274 | \ ft, string(ft), string(names)) 275 | augroup END 276 | endfor 277 | 278 | call s:reorg_rtp() 279 | filetype plugin indent on 280 | if has('vim_starting') 281 | if has('syntax') && !exists('g:syntax_on') 282 | syntax enable 283 | end 284 | else 285 | call s:reload_plugins() 286 | endif 287 | endfunction 288 | 289 | function! s:loaded_names() 290 | return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)') 291 | endfunction 292 | 293 | function! s:load_plugin(spec) 294 | call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim') 295 | endfunction 296 | 297 | function! s:reload_plugins() 298 | for name in s:loaded_names() 299 | call s:load_plugin(g:plugs[name]) 300 | endfor 301 | endfunction 302 | 303 | function! s:trim(str) 304 | return substitute(a:str, '[\/]\+$', '', '') 305 | endfunction 306 | 307 | function! s:version_requirement(val, min) 308 | for idx in range(0, len(a:min) - 1) 309 | let v = get(a:val, idx, 0) 310 | if v < a:min[idx] | return 0 311 | elseif v > a:min[idx] | return 1 312 | endif 313 | endfor 314 | return 1 315 | endfunction 316 | 317 | function! s:git_version_requirement(...) 318 | if !exists('s:git_version') 319 | let s:git_version = map(split(split(s:system('git --version'))[2], '\.'), 'str2nr(v:val)') 320 | endif 321 | return s:version_requirement(s:git_version, a:000) 322 | endfunction 323 | 324 | function! s:progress_opt(base) 325 | return a:base && !s:is_win && 326 | \ s:git_version_requirement(1, 7, 1) ? '--progress' : '' 327 | endfunction 328 | 329 | if s:is_win 330 | function! s:rtp(spec) 331 | return s:path(a:spec.dir . get(a:spec, 'rtp', '')) 332 | endfunction 333 | 334 | function! s:path(path) 335 | return s:trim(substitute(a:path, '/', '\', 'g')) 336 | endfunction 337 | 338 | function! s:dirpath(path) 339 | return s:path(a:path) . '\' 340 | endfunction 341 | 342 | function! s:is_local_plug(repo) 343 | return a:repo =~? '^[a-z]:\|^[%~]' 344 | endfunction 345 | else 346 | function! s:rtp(spec) 347 | return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) 348 | endfunction 349 | 350 | function! s:path(path) 351 | return s:trim(a:path) 352 | endfunction 353 | 354 | function! s:dirpath(path) 355 | return substitute(a:path, '[/\\]*$', '/', '') 356 | endfunction 357 | 358 | function! s:is_local_plug(repo) 359 | return a:repo[0] =~ '[/$~]' 360 | endfunction 361 | endif 362 | 363 | function! s:err(msg) 364 | echohl ErrorMsg 365 | echom '[vim-plug] '.a:msg 366 | echohl None 367 | endfunction 368 | 369 | function! s:warn(cmd, msg) 370 | echohl WarningMsg 371 | execute a:cmd 'a:msg' 372 | echohl None 373 | endfunction 374 | 375 | function! s:esc(path) 376 | return escape(a:path, ' ') 377 | endfunction 378 | 379 | function! s:escrtp(path) 380 | return escape(a:path, ' ,') 381 | endfunction 382 | 383 | function! s:remove_rtp() 384 | for name in s:loaded_names() 385 | let rtp = s:rtp(g:plugs[name]) 386 | execute 'set rtp-='.s:escrtp(rtp) 387 | let after = globpath(rtp, 'after') 388 | if isdirectory(after) 389 | execute 'set rtp-='.s:escrtp(after) 390 | endif 391 | endfor 392 | endfunction 393 | 394 | function! s:reorg_rtp() 395 | if !empty(s:first_rtp) 396 | execute 'set rtp-='.s:first_rtp 397 | execute 'set rtp-='.s:last_rtp 398 | endif 399 | 400 | " &rtp is modified from outside 401 | if exists('s:prtp') && s:prtp !=# &rtp 402 | call s:remove_rtp() 403 | unlet! s:middle 404 | endif 405 | 406 | let s:middle = get(s:, 'middle', &rtp) 407 | let rtps = map(s:loaded_names(), 's:rtp(g:plugs[v:val])') 408 | let afters = filter(map(copy(rtps), 'globpath(v:val, "after")'), '!empty(v:val)') 409 | let rtp = join(map(rtps, 'escape(v:val, ",")'), ',') 410 | \ . ','.s:middle.',' 411 | \ . join(map(afters, 'escape(v:val, ",")'), ',') 412 | let &rtp = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g') 413 | let s:prtp = &rtp 414 | 415 | if !empty(s:first_rtp) 416 | execute 'set rtp^='.s:first_rtp 417 | execute 'set rtp+='.s:last_rtp 418 | endif 419 | endfunction 420 | 421 | function! s:doautocmd(...) 422 | if exists('#'.join(a:000, '#')) 423 | execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '' : '') join(a:000) 424 | endif 425 | endfunction 426 | 427 | function! s:dobufread(names) 428 | for name in a:names 429 | let path = s:rtp(g:plugs[name]).'/**' 430 | for dir in ['ftdetect', 'ftplugin'] 431 | if len(finddir(dir, path)) 432 | if exists('#BufRead') 433 | doautocmd BufRead 434 | endif 435 | return 436 | endif 437 | endfor 438 | endfor 439 | endfunction 440 | 441 | function! plug#load(...) 442 | if a:0 == 0 443 | return s:err('Argument missing: plugin name(s) required') 444 | endif 445 | if !exists('g:plugs') 446 | return s:err('plug#begin was not called') 447 | endif 448 | let names = a:0 == 1 && type(a:1) == s:TYPE.list ? a:1 : a:000 449 | let unknowns = filter(copy(names), '!has_key(g:plugs, v:val)') 450 | if !empty(unknowns) 451 | let s = len(unknowns) > 1 ? 's' : '' 452 | return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', '))) 453 | end 454 | let unloaded = filter(copy(names), '!get(s:loaded, v:val, 0)') 455 | if !empty(unloaded) 456 | for name in unloaded 457 | call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) 458 | endfor 459 | call s:dobufread(unloaded) 460 | return 1 461 | end 462 | return 0 463 | endfunction 464 | 465 | function! s:remove_triggers(name) 466 | if !has_key(s:triggers, a:name) 467 | return 468 | endif 469 | for cmd in s:triggers[a:name].cmd 470 | execute 'silent! delc' cmd 471 | endfor 472 | for map in s:triggers[a:name].map 473 | execute 'silent! unmap' map 474 | execute 'silent! iunmap' map 475 | endfor 476 | call remove(s:triggers, a:name) 477 | endfunction 478 | 479 | function! s:lod(names, types, ...) 480 | for name in a:names 481 | call s:remove_triggers(name) 482 | let s:loaded[name] = 1 483 | endfor 484 | call s:reorg_rtp() 485 | 486 | for name in a:names 487 | let rtp = s:rtp(g:plugs[name]) 488 | for dir in a:types 489 | call s:source(rtp, dir.'/**/*.vim') 490 | endfor 491 | if a:0 492 | if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2)) 493 | execute 'runtime' a:1 494 | endif 495 | call s:source(rtp, a:2) 496 | endif 497 | call s:doautocmd('User', name) 498 | endfor 499 | endfunction 500 | 501 | function! s:lod_ft(pat, names) 502 | let syn = 'syntax/'.a:pat.'.vim' 503 | call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn) 504 | execute 'autocmd! PlugLOD FileType' a:pat 505 | call s:doautocmd('filetypeplugin', 'FileType') 506 | call s:doautocmd('filetypeindent', 'FileType') 507 | endfunction 508 | 509 | function! s:lod_cmd(cmd, bang, l1, l2, args, names) 510 | call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) 511 | call s:dobufread(a:names) 512 | execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args) 513 | endfunction 514 | 515 | function! s:lod_map(map, names, with_prefix, prefix) 516 | call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin']) 517 | call s:dobufread(a:names) 518 | let extra = '' 519 | while 1 520 | let c = getchar(0) 521 | if c == 0 522 | break 523 | endif 524 | let extra .= nr2char(c) 525 | endwhile 526 | 527 | if a:with_prefix 528 | let prefix = v:count ? v:count : '' 529 | let prefix .= '"'.v:register.a:prefix 530 | if mode(1) == 'no' 531 | if v:operator == 'c' 532 | let prefix = "\" . prefix 533 | endif 534 | let prefix .= v:operator 535 | endif 536 | call feedkeys(prefix, 'n') 537 | endif 538 | call feedkeys(substitute(a:map, '^', "\", '') . extra) 539 | endfunction 540 | 541 | function! plug#(repo, ...) 542 | if a:0 > 1 543 | return s:err('Invalid number of arguments (1..2)') 544 | endif 545 | 546 | try 547 | let repo = s:trim(a:repo) 548 | let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec 549 | let name = get(opts, 'as', fnamemodify(repo, ':t:s?\.git$??')) 550 | let spec = extend(s:infer_properties(name, repo), opts) 551 | if !has_key(g:plugs, name) 552 | call add(g:plugs_order, name) 553 | endif 554 | let g:plugs[name] = spec 555 | let s:loaded[name] = get(s:loaded, name, 0) 556 | catch 557 | return s:err(v:exception) 558 | endtry 559 | endfunction 560 | 561 | function! s:parse_options(arg) 562 | let opts = copy(s:base_spec) 563 | let type = type(a:arg) 564 | if type == s:TYPE.string 565 | let opts.tag = a:arg 566 | elseif type == s:TYPE.dict 567 | call extend(opts, a:arg) 568 | if has_key(opts, 'dir') 569 | let opts.dir = s:dirpath(expand(opts.dir)) 570 | endif 571 | else 572 | throw 'Invalid argument type (expected: string or dictionary)' 573 | endif 574 | return opts 575 | endfunction 576 | 577 | function! s:infer_properties(name, repo) 578 | let repo = a:repo 579 | if s:is_local_plug(repo) 580 | return { 'dir': s:dirpath(expand(repo)) } 581 | else 582 | if repo =~ ':' 583 | let uri = repo 584 | else 585 | if repo !~ '/' 586 | throw printf('Invalid argument: %s (implicit `vim-scripts'' expansion is deprecated)', repo) 587 | endif 588 | let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') 589 | let uri = printf(fmt, repo) 590 | endif 591 | return { 'dir': s:dirpath(g:plug_home.'/'.a:name), 'uri': uri } 592 | endif 593 | endfunction 594 | 595 | function! s:install(force, names) 596 | call s:update_impl(0, a:force, a:names) 597 | endfunction 598 | 599 | function! s:update(force, names) 600 | call s:update_impl(1, a:force, a:names) 601 | endfunction 602 | 603 | function! plug#helptags() 604 | if !exists('g:plugs') 605 | return s:err('plug#begin was not called') 606 | endif 607 | for spec in values(g:plugs) 608 | let docd = join([s:rtp(spec), 'doc'], '/') 609 | if isdirectory(docd) 610 | silent! execute 'helptags' s:esc(docd) 611 | endif 612 | endfor 613 | return 1 614 | endfunction 615 | 616 | function! s:syntax() 617 | syntax clear 618 | syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber 619 | syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX 620 | syn match plugNumber /[0-9]\+[0-9.]*/ contained 621 | syn match plugBracket /[[\]]/ contained 622 | syn match plugX /x/ contained 623 | syn match plugDash /^-/ 624 | syn match plugPlus /^+/ 625 | syn match plugStar /^*/ 626 | syn match plugMessage /\(^- \)\@<=.*/ 627 | syn match plugName /\(^- \)\@<=[^ ]*:/ 628 | syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/ 629 | syn match plugTag /(tag: [^)]\+)/ 630 | syn match plugInstall /\(^+ \)\@<=[^:]*/ 631 | syn match plugUpdate /\(^* \)\@<=[^:]*/ 632 | syn match plugCommit /^ \X*[0-9a-f]\{7,9} .*/ contains=plugRelDate,plugEdge,plugTag 633 | syn match plugEdge /^ \X\+$/ 634 | syn match plugEdge /^ \X*/ contained nextgroup=plugSha 635 | syn match plugSha /[0-9a-f]\{7,9}/ contained 636 | syn match plugRelDate /([^)]*)$/ contained 637 | syn match plugNotLoaded /(not loaded)$/ 638 | syn match plugError /^x.*/ 639 | syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/ 640 | syn match plugH2 /^.*:\n-\+$/ 641 | syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean 642 | hi def link plug1 Title 643 | hi def link plug2 Repeat 644 | hi def link plugH2 Type 645 | hi def link plugX Exception 646 | hi def link plugBracket Structure 647 | hi def link plugNumber Number 648 | 649 | hi def link plugDash Special 650 | hi def link plugPlus Constant 651 | hi def link plugStar Boolean 652 | 653 | hi def link plugMessage Function 654 | hi def link plugName Label 655 | hi def link plugInstall Function 656 | hi def link plugUpdate Type 657 | 658 | hi def link plugError Error 659 | hi def link plugDeleted Ignore 660 | hi def link plugRelDate Comment 661 | hi def link plugEdge PreProc 662 | hi def link plugSha Identifier 663 | hi def link plugTag Constant 664 | 665 | hi def link plugNotLoaded Comment 666 | endfunction 667 | 668 | function! s:lpad(str, len) 669 | return a:str . repeat(' ', a:len - len(a:str)) 670 | endfunction 671 | 672 | function! s:lines(msg) 673 | return split(a:msg, "[\r\n]") 674 | endfunction 675 | 676 | function! s:lastline(msg) 677 | return get(s:lines(a:msg), -1, '') 678 | endfunction 679 | 680 | function! s:new_window() 681 | execute get(g:, 'plug_window', 'vertical topleft new') 682 | endfunction 683 | 684 | function! s:plug_window_exists() 685 | let buflist = tabpagebuflist(s:plug_tab) 686 | return !empty(buflist) && index(buflist, s:plug_buf) >= 0 687 | endfunction 688 | 689 | function! s:switch_in() 690 | if !s:plug_window_exists() 691 | return 0 692 | endif 693 | 694 | if winbufnr(0) != s:plug_buf 695 | let s:pos = [tabpagenr(), winnr(), winsaveview()] 696 | execute 'normal!' s:plug_tab.'gt' 697 | let winnr = bufwinnr(s:plug_buf) 698 | execute winnr.'wincmd w' 699 | call add(s:pos, winsaveview()) 700 | else 701 | let s:pos = [winsaveview()] 702 | endif 703 | 704 | setlocal modifiable 705 | return 1 706 | endfunction 707 | 708 | function! s:switch_out(...) 709 | call winrestview(s:pos[-1]) 710 | setlocal nomodifiable 711 | if a:0 > 0 712 | execute a:1 713 | endif 714 | 715 | if len(s:pos) > 1 716 | execute 'normal!' s:pos[0].'gt' 717 | execute s:pos[1] 'wincmd w' 718 | call winrestview(s:pos[2]) 719 | endif 720 | endfunction 721 | 722 | function! s:finish_bindings() 723 | nnoremap R :call retry() 724 | nnoremap D :PlugDiff 725 | nnoremap S :PlugStatus 726 | nnoremap U :call status_update() 727 | xnoremap U :call status_update() 728 | nnoremap ]] :silent! call section('') 729 | nnoremap [[ :silent! call section('b') 730 | endfunction 731 | 732 | function! s:prepare(...) 733 | if empty(getcwd()) 734 | throw 'Invalid current working directory. Cannot proceed.' 735 | endif 736 | 737 | for evar in ['$GIT_DIR', '$GIT_WORK_TREE'] 738 | if exists(evar) 739 | throw evar.' detected. Cannot proceed.' 740 | endif 741 | endfor 742 | 743 | call s:job_abort() 744 | if s:switch_in() 745 | if b:plug_preview == 1 746 | pc 747 | endif 748 | enew 749 | else 750 | call s:new_window() 751 | endif 752 | 753 | nnoremap q :if b:plug_preview==1pcendifbd 754 | if a:0 == 0 755 | call s:finish_bindings() 756 | endif 757 | let b:plug_preview = -1 758 | let s:plug_tab = tabpagenr() 759 | let s:plug_buf = winbufnr(0) 760 | call s:assign_name() 761 | 762 | for k in ['', 'L', 'o', 'X', 'd', 'dd'] 763 | execute 'silent! unmap ' k 764 | endfor 765 | setlocal buftype=nofile bufhidden=wipe nobuflisted nolist noswapfile nowrap cursorline modifiable nospell 766 | setf vim-plug 767 | if exists('g:syntax_on') 768 | call s:syntax() 769 | endif 770 | endfunction 771 | 772 | function! s:assign_name() 773 | " Assign buffer name 774 | let prefix = '[Plugins]' 775 | let name = prefix 776 | let idx = 2 777 | while bufexists(name) 778 | let name = printf('%s (%s)', prefix, idx) 779 | let idx = idx + 1 780 | endwhile 781 | silent! execute 'f' fnameescape(name) 782 | endfunction 783 | 784 | function! s:chsh(swap) 785 | let prev = [&shell, &shellcmdflag, &shellredir] 786 | if s:is_win 787 | set shell=cmd.exe shellcmdflag=/c shellredir=>%s\ 2>&1 788 | elseif a:swap 789 | set shell=sh shellredir=>%s\ 2>&1 790 | endif 791 | return prev 792 | endfunction 793 | 794 | function! s:bang(cmd, ...) 795 | try 796 | let [sh, shellcmdflag, shrd] = s:chsh(a:0) 797 | " FIXME: Escaping is incomplete. We could use shellescape with eval, 798 | " but it won't work on Windows. 799 | let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd 800 | if s:is_win 801 | let batchfile = tempname().'.bat' 802 | call writefile(['@echo off', cmd], batchfile) 803 | let cmd = batchfile 804 | endif 805 | let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%') 806 | execute "normal! :execute g:_plug_bang\\" 807 | finally 808 | unlet g:_plug_bang 809 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] 810 | if s:is_win 811 | call delete(batchfile) 812 | endif 813 | endtry 814 | return v:shell_error ? 'Exit status: ' . v:shell_error : '' 815 | endfunction 816 | 817 | function! s:regress_bar() 818 | let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '') 819 | call s:progress_bar(2, bar, len(bar)) 820 | endfunction 821 | 822 | function! s:is_updated(dir) 823 | return !empty(s:system_chomp('git log --pretty=format:"%h" "HEAD...HEAD@{1}"', a:dir)) 824 | endfunction 825 | 826 | function! s:do(pull, force, todo) 827 | for [name, spec] in items(a:todo) 828 | if !isdirectory(spec.dir) 829 | continue 830 | endif 831 | let installed = has_key(s:update.new, name) 832 | let updated = installed ? 0 : 833 | \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir)) 834 | if a:force || installed || updated 835 | execute 'cd' s:esc(spec.dir) 836 | call append(3, '- Post-update hook for '. name .' ... ') 837 | let error = '' 838 | let type = type(spec.do) 839 | if type == s:TYPE.string 840 | if spec.do[0] == ':' 841 | if !get(s:loaded, name, 0) 842 | let s:loaded[name] = 1 843 | call s:reorg_rtp() 844 | endif 845 | call s:load_plugin(spec) 846 | try 847 | execute spec.do[1:] 848 | catch 849 | let error = v:exception 850 | endtry 851 | if !s:plug_window_exists() 852 | cd - 853 | throw 'Warning: vim-plug was terminated by the post-update hook of '.name 854 | endif 855 | else 856 | let error = s:bang(spec.do) 857 | endif 858 | elseif type == s:TYPE.funcref 859 | try 860 | let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged') 861 | call spec.do({ 'name': name, 'status': status, 'force': a:force }) 862 | catch 863 | let error = v:exception 864 | endtry 865 | else 866 | let error = 'Invalid hook type' 867 | endif 868 | call s:switch_in() 869 | call setline(4, empty(error) ? (getline(4) . 'OK') 870 | \ : ('x' . getline(4)[1:] . error)) 871 | if !empty(error) 872 | call add(s:update.errors, name) 873 | call s:regress_bar() 874 | endif 875 | cd - 876 | endif 877 | endfor 878 | endfunction 879 | 880 | function! s:hash_match(a, b) 881 | return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0 882 | endfunction 883 | 884 | function! s:checkout(spec) 885 | let sha = a:spec.commit 886 | let output = s:system('git rev-parse HEAD', a:spec.dir) 887 | if !v:shell_error && !s:hash_match(sha, s:lines(output)[0]) 888 | let output = s:system( 889 | \ 'git fetch --depth 999999 && git checkout '.s:esc(sha).' --', a:spec.dir) 890 | endif 891 | return output 892 | endfunction 893 | 894 | function! s:finish(pull) 895 | let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen')) 896 | if new_frozen 897 | let s = new_frozen > 1 ? 's' : '' 898 | call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s)) 899 | endif 900 | call append(3, '- Finishing ... ') | 4 901 | redraw 902 | call plug#helptags() 903 | call plug#end() 904 | call setline(4, getline(4) . 'Done!') 905 | redraw 906 | let msgs = [] 907 | if !empty(s:update.errors) 908 | call add(msgs, "Press 'R' to retry.") 909 | endif 910 | if a:pull && len(s:update.new) < len(filter(getline(5, '$'), 911 | \ "v:val =~ '^- ' && v:val !~# 'Already up.to.date'")) 912 | call add(msgs, "Press 'D' to see the updated changes.") 913 | endif 914 | echo join(msgs, ' ') 915 | call s:finish_bindings() 916 | endfunction 917 | 918 | function! s:retry() 919 | if empty(s:update.errors) 920 | return 921 | endif 922 | echo 923 | call s:update_impl(s:update.pull, s:update.force, 924 | \ extend(copy(s:update.errors), [s:update.threads])) 925 | endfunction 926 | 927 | function! s:is_managed(name) 928 | return has_key(g:plugs[a:name], 'uri') 929 | endfunction 930 | 931 | function! s:names(...) 932 | return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)')) 933 | endfunction 934 | 935 | function! s:check_ruby() 936 | silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'") 937 | if !exists('g:plug_ruby') 938 | redraw! 939 | return s:warn('echom', 'Warning: Ruby interface is broken') 940 | endif 941 | let ruby_version = split(g:plug_ruby, '\.') 942 | unlet g:plug_ruby 943 | return s:version_requirement(ruby_version, [1, 8, 7]) 944 | endfunction 945 | 946 | function! s:update_impl(pull, force, args) abort 947 | let sync = index(a:args, '--sync') >= 0 || has('vim_starting') 948 | let args = filter(copy(a:args), 'v:val != "--sync"') 949 | let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ? 950 | \ remove(args, -1) : get(g:, 'plug_threads', 16) 951 | 952 | let managed = filter(copy(g:plugs), 's:is_managed(v:key)') 953 | let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') : 954 | \ filter(managed, 'index(args, v:key) >= 0') 955 | 956 | if empty(todo) 957 | return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install')) 958 | endif 959 | 960 | if !s:is_win && s:git_version_requirement(2, 3) 961 | let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : '' 962 | let $GIT_TERMINAL_PROMPT = 0 963 | for plug in values(todo) 964 | let plug.uri = substitute(plug.uri, 965 | \ '^https://git::@github\.com', 'https://github.com', '') 966 | endfor 967 | endif 968 | 969 | if !isdirectory(g:plug_home) 970 | try 971 | call mkdir(g:plug_home, 'p') 972 | catch 973 | return s:err(printf('Invalid plug directory: %s. '. 974 | \ 'Try to call plug#begin with a valid directory', g:plug_home)) 975 | endtry 976 | endif 977 | 978 | if has('nvim') && !exists('*jobwait') && threads > 1 979 | call s:warn('echom', '[vim-plug] Update Neovim for parallel installer') 980 | endif 981 | 982 | let use_job = s:nvim || s:vim8 983 | let python = (has('python') || has('python3')) && !use_job 984 | 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() 985 | 986 | let s:update = { 987 | \ 'start': reltime(), 988 | \ 'all': todo, 989 | \ 'todo': copy(todo), 990 | \ 'errors': [], 991 | \ 'pull': a:pull, 992 | \ 'force': a:force, 993 | \ 'new': {}, 994 | \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1, 995 | \ 'bar': '', 996 | \ 'fin': 0 997 | \ } 998 | 999 | call s:prepare(1) 1000 | call append(0, ['', '']) 1001 | normal! 2G 1002 | silent! redraw 1003 | 1004 | let s:clone_opt = get(g:, 'plug_shallow', 1) ? 1005 | \ '--depth 1' . (s:git_version_requirement(1, 7, 10) ? ' --no-single-branch' : '') : '' 1006 | 1007 | if has('win32unix') 1008 | let s:clone_opt .= ' -c core.eol=lf -c core.autocrlf=input' 1009 | endif 1010 | 1011 | " Python version requirement (>= 2.7) 1012 | if python && !has('python3') && !ruby && !use_job && s:update.threads > 1 1013 | redir => pyv 1014 | silent python import platform; print platform.python_version() 1015 | redir END 1016 | let python = s:version_requirement( 1017 | \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6]) 1018 | endif 1019 | 1020 | if (python || ruby) && s:update.threads > 1 1021 | try 1022 | let imd = &imd 1023 | if s:mac_gui 1024 | set noimd 1025 | endif 1026 | if ruby 1027 | call s:update_ruby() 1028 | else 1029 | call s:update_python() 1030 | endif 1031 | catch 1032 | let lines = getline(4, '$') 1033 | let printed = {} 1034 | silent! 4,$d _ 1035 | for line in lines 1036 | let name = s:extract_name(line, '.', '') 1037 | if empty(name) || !has_key(printed, name) 1038 | call append('$', line) 1039 | if !empty(name) 1040 | let printed[name] = 1 1041 | if line[0] == 'x' && index(s:update.errors, name) < 0 1042 | call add(s:update.errors, name) 1043 | end 1044 | endif 1045 | endif 1046 | endfor 1047 | finally 1048 | let &imd = imd 1049 | call s:update_finish() 1050 | endtry 1051 | else 1052 | call s:update_vim() 1053 | while use_job && sync 1054 | sleep 100m 1055 | if s:update.fin 1056 | break 1057 | endif 1058 | endwhile 1059 | endif 1060 | endfunction 1061 | 1062 | function! s:log4(name, msg) 1063 | call setline(4, printf('- %s (%s)', a:msg, a:name)) 1064 | redraw 1065 | endfunction 1066 | 1067 | function! s:update_finish() 1068 | if exists('s:git_terminal_prompt') 1069 | let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt 1070 | endif 1071 | if s:switch_in() 1072 | call append(3, '- Updating ...') | 4 1073 | 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))')) 1074 | let [pos, _] = s:logpos(name) 1075 | if !pos 1076 | continue 1077 | endif 1078 | if has_key(spec, 'commit') 1079 | call s:log4(name, 'Checking out '.spec.commit) 1080 | let out = s:checkout(spec) 1081 | elseif has_key(spec, 'tag') 1082 | let tag = spec.tag 1083 | if tag =~ '\*' 1084 | let tags = s:lines(s:system('git tag --list '.s:shellesc(tag).' --sort -version:refname 2>&1', spec.dir)) 1085 | if !v:shell_error && !empty(tags) 1086 | let tag = tags[0] 1087 | call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag)) 1088 | call append(3, '') 1089 | endif 1090 | endif 1091 | call s:log4(name, 'Checking out '.tag) 1092 | let out = s:system('git checkout -q '.s:esc(tag).' -- 2>&1', spec.dir) 1093 | else 1094 | let branch = s:esc(get(spec, 'branch', 'master')) 1095 | call s:log4(name, 'Merging origin/'.branch) 1096 | let out = s:system('git checkout -q '.branch.' -- 2>&1' 1097 | \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only origin/'.branch.' 2>&1')), spec.dir) 1098 | endif 1099 | if !v:shell_error && filereadable(spec.dir.'/.gitmodules') && 1100 | \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir)) 1101 | call s:log4(name, 'Updating submodules. This may take a while.') 1102 | let out .= s:bang('git submodule update --init --recursive 2>&1', spec.dir) 1103 | endif 1104 | let msg = s:format_message(v:shell_error ? 'x': '-', name, out) 1105 | if v:shell_error 1106 | call add(s:update.errors, name) 1107 | call s:regress_bar() 1108 | silent execute pos 'd _' 1109 | call append(4, msg) | 4 1110 | elseif !empty(out) 1111 | call setline(pos, msg[0]) 1112 | endif 1113 | redraw 1114 | endfor 1115 | silent 4 d _ 1116 | try 1117 | 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")')) 1118 | catch 1119 | call s:warn('echom', v:exception) 1120 | call s:warn('echo', '') 1121 | return 1122 | endtry 1123 | call s:finish(s:update.pull) 1124 | call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.') 1125 | call s:switch_out('normal! gg') 1126 | endif 1127 | endfunction 1128 | 1129 | function! s:job_abort() 1130 | if (!s:nvim && !s:vim8) || !exists('s:jobs') 1131 | return 1132 | endif 1133 | 1134 | for [name, j] in items(s:jobs) 1135 | if s:nvim 1136 | silent! call jobstop(j.jobid) 1137 | elseif s:vim8 1138 | silent! call job_stop(j.jobid) 1139 | endif 1140 | if j.new 1141 | call s:system('rm -rf ' . s:shellesc(g:plugs[name].dir)) 1142 | endif 1143 | endfor 1144 | let s:jobs = {} 1145 | endfunction 1146 | 1147 | function! s:last_non_empty_line(lines) 1148 | let len = len(a:lines) 1149 | for idx in range(len) 1150 | let line = a:lines[len-idx-1] 1151 | if !empty(line) 1152 | return line 1153 | endif 1154 | endfor 1155 | return '' 1156 | endfunction 1157 | 1158 | function! s:job_out_cb(self, data) abort 1159 | let self = a:self 1160 | let data = remove(self.lines, -1) . a:data 1161 | let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]') 1162 | call extend(self.lines, lines) 1163 | " To reduce the number of buffer updates 1164 | let self.tick = get(self, 'tick', -1) + 1 1165 | if !self.running || self.tick % len(s:jobs) == 0 1166 | let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-') 1167 | let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines) 1168 | call s:log(bullet, self.name, result) 1169 | endif 1170 | endfunction 1171 | 1172 | function! s:job_exit_cb(self, data) abort 1173 | let a:self.running = 0 1174 | let a:self.error = a:data != 0 1175 | call s:reap(a:self.name) 1176 | call s:tick() 1177 | endfunction 1178 | 1179 | function! s:job_cb(fn, job, ch, data) 1180 | if !s:plug_window_exists() " plug window closed 1181 | return s:job_abort() 1182 | endif 1183 | call call(a:fn, [a:job, a:data]) 1184 | endfunction 1185 | 1186 | function! s:nvim_cb(job_id, data, event) dict abort 1187 | return a:event == 'stdout' ? 1188 | \ s:job_cb('s:job_out_cb', self, 0, join(a:data, "\n")) : 1189 | \ s:job_cb('s:job_exit_cb', self, 0, a:data) 1190 | endfunction 1191 | 1192 | function! s:spawn(name, cmd, opts) 1193 | let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''], 1194 | \ 'batchfile': (s:is_win && (s:nvim || s:vim8)) ? tempname().'.bat' : '', 1195 | \ 'new': get(a:opts, 'new', 0) } 1196 | let s:jobs[a:name] = job 1197 | let cmd = has_key(a:opts, 'dir') ? s:with_cd(a:cmd, a:opts.dir) : a:cmd 1198 | if !empty(job.batchfile) 1199 | call writefile(['@echo off', cmd], job.batchfile) 1200 | let cmd = job.batchfile 1201 | endif 1202 | let argv = add(s:is_win ? ['cmd', '/c'] : ['sh', '-c'], cmd) 1203 | 1204 | if s:nvim 1205 | call extend(job, { 1206 | \ 'on_stdout': function('s:nvim_cb'), 1207 | \ 'on_exit': function('s:nvim_cb'), 1208 | \ }) 1209 | let jid = jobstart(argv, job) 1210 | if jid > 0 1211 | let job.jobid = jid 1212 | else 1213 | let job.running = 0 1214 | let job.error = 1 1215 | let job.lines = [jid < 0 ? argv[0].' is not executable' : 1216 | \ 'Invalid arguments (or job table is full)'] 1217 | endif 1218 | elseif s:vim8 1219 | let jid = job_start(s:is_win ? join(argv, ' ') : argv, { 1220 | \ 'out_cb': function('s:job_cb', ['s:job_out_cb', job]), 1221 | \ 'exit_cb': function('s:job_cb', ['s:job_exit_cb', job]), 1222 | \ 'out_mode': 'raw' 1223 | \}) 1224 | if job_status(jid) == 'run' 1225 | let job.jobid = jid 1226 | else 1227 | let job.running = 0 1228 | let job.error = 1 1229 | let job.lines = ['Failed to start job'] 1230 | endif 1231 | else 1232 | let job.lines = s:lines(call('s:system', [cmd])) 1233 | let job.error = v:shell_error != 0 1234 | let job.running = 0 1235 | endif 1236 | endfunction 1237 | 1238 | function! s:reap(name) 1239 | let job = s:jobs[a:name] 1240 | if job.error 1241 | call add(s:update.errors, a:name) 1242 | elseif get(job, 'new', 0) 1243 | let s:update.new[a:name] = 1 1244 | endif 1245 | let s:update.bar .= job.error ? 'x' : '=' 1246 | 1247 | let bullet = job.error ? 'x' : '-' 1248 | let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines) 1249 | call s:log(bullet, a:name, empty(result) ? 'OK' : result) 1250 | call s:bar() 1251 | 1252 | if has_key(job, 'batchfile') && !empty(job.batchfile) 1253 | call delete(job.batchfile) 1254 | endif 1255 | call remove(s:jobs, a:name) 1256 | endfunction 1257 | 1258 | function! s:bar() 1259 | if s:switch_in() 1260 | let total = len(s:update.all) 1261 | call setline(1, (s:update.pull ? 'Updating' : 'Installing'). 1262 | \ ' plugins ('.len(s:update.bar).'/'.total.')') 1263 | call s:progress_bar(2, s:update.bar, total) 1264 | call s:switch_out() 1265 | endif 1266 | endfunction 1267 | 1268 | function! s:logpos(name) 1269 | for i in range(4, line('$')) 1270 | if getline(i) =~# '^[-+x*] '.a:name.':' 1271 | for j in range(i + 1, line('$')) 1272 | if getline(j) !~ '^ ' 1273 | return [i, j - 1] 1274 | endif 1275 | endfor 1276 | return [i, i] 1277 | endif 1278 | endfor 1279 | return [0, 0] 1280 | endfunction 1281 | 1282 | function! s:log(bullet, name, lines) 1283 | if s:switch_in() 1284 | let [b, e] = s:logpos(a:name) 1285 | if b > 0 1286 | silent execute printf('%d,%d d _', b, e) 1287 | if b > winheight('.') 1288 | let b = 4 1289 | endif 1290 | else 1291 | let b = 4 1292 | endif 1293 | " FIXME For some reason, nomodifiable is set after :d in vim8 1294 | setlocal modifiable 1295 | call append(b - 1, s:format_message(a:bullet, a:name, a:lines)) 1296 | call s:switch_out() 1297 | endif 1298 | endfunction 1299 | 1300 | function! s:update_vim() 1301 | let s:jobs = {} 1302 | 1303 | call s:bar() 1304 | call s:tick() 1305 | endfunction 1306 | 1307 | function! s:tick() 1308 | let pull = s:update.pull 1309 | let prog = s:progress_opt(s:nvim || s:vim8) 1310 | while 1 " Without TCO, Vim stack is bound to explode 1311 | if empty(s:update.todo) 1312 | if empty(s:jobs) && !s:update.fin 1313 | call s:update_finish() 1314 | let s:update.fin = 1 1315 | endif 1316 | return 1317 | endif 1318 | 1319 | let name = keys(s:update.todo)[0] 1320 | let spec = remove(s:update.todo, name) 1321 | let new = !isdirectory(spec.dir) 1322 | 1323 | call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...') 1324 | redraw 1325 | 1326 | let has_tag = has_key(spec, 'tag') 1327 | if !new 1328 | let [error, _] = s:git_validate(spec, 0) 1329 | if empty(error) 1330 | if pull 1331 | let fetch_opt = (has_tag && !empty(globpath(spec.dir, '.git/shallow'))) ? '--depth 99999999' : '' 1332 | call s:spawn(name, printf('git fetch %s %s 2>&1', fetch_opt, prog), { 'dir': spec.dir }) 1333 | else 1334 | let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 } 1335 | endif 1336 | else 1337 | let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 } 1338 | endif 1339 | else 1340 | call s:spawn(name, 1341 | \ printf('git clone %s %s %s %s 2>&1', 1342 | \ has_tag ? '' : s:clone_opt, 1343 | \ prog, 1344 | \ s:shellesc(spec.uri), 1345 | \ s:shellesc(s:trim(spec.dir))), { 'new': 1 }) 1346 | endif 1347 | 1348 | if !s:jobs[name].running 1349 | call s:reap(name) 1350 | endif 1351 | if len(s:jobs) >= s:update.threads 1352 | break 1353 | endif 1354 | endwhile 1355 | endfunction 1356 | 1357 | function! s:update_python() 1358 | let py_exe = has('python') ? 'python' : 'python3' 1359 | execute py_exe "<< EOF" 1360 | import datetime 1361 | import functools 1362 | import os 1363 | try: 1364 | import queue 1365 | except ImportError: 1366 | import Queue as queue 1367 | import random 1368 | import re 1369 | import shutil 1370 | import signal 1371 | import subprocess 1372 | import tempfile 1373 | import threading as thr 1374 | import time 1375 | import traceback 1376 | import vim 1377 | 1378 | G_NVIM = vim.eval("has('nvim')") == '1' 1379 | G_PULL = vim.eval('s:update.pull') == '1' 1380 | G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1 1381 | G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)')) 1382 | G_CLONE_OPT = vim.eval('s:clone_opt') 1383 | G_PROGRESS = vim.eval('s:progress_opt(1)') 1384 | G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads')) 1385 | G_STOP = thr.Event() 1386 | G_IS_WIN = vim.eval('s:is_win') == '1' 1387 | 1388 | class PlugError(Exception): 1389 | def __init__(self, msg): 1390 | self.msg = msg 1391 | class CmdTimedOut(PlugError): 1392 | pass 1393 | class CmdFailed(PlugError): 1394 | pass 1395 | class InvalidURI(PlugError): 1396 | pass 1397 | class Action(object): 1398 | INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-'] 1399 | 1400 | class Buffer(object): 1401 | def __init__(self, lock, num_plugs, is_pull): 1402 | self.bar = '' 1403 | self.event = 'Updating' if is_pull else 'Installing' 1404 | self.lock = lock 1405 | self.maxy = int(vim.eval('winheight(".")')) 1406 | self.num_plugs = num_plugs 1407 | 1408 | def __where(self, name): 1409 | """ Find first line with name in current buffer. Return line num. """ 1410 | found, lnum = False, 0 1411 | matcher = re.compile('^[-+x*] {0}:'.format(name)) 1412 | for line in vim.current.buffer: 1413 | if matcher.search(line) is not None: 1414 | found = True 1415 | break 1416 | lnum += 1 1417 | 1418 | if not found: 1419 | lnum = -1 1420 | return lnum 1421 | 1422 | def header(self): 1423 | curbuf = vim.current.buffer 1424 | curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs) 1425 | 1426 | num_spaces = self.num_plugs - len(self.bar) 1427 | curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ') 1428 | 1429 | with self.lock: 1430 | vim.command('normal! 2G') 1431 | vim.command('redraw') 1432 | 1433 | def write(self, action, name, lines): 1434 | first, rest = lines[0], lines[1:] 1435 | msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)] 1436 | msg.extend([' ' + line for line in rest]) 1437 | 1438 | try: 1439 | if action == Action.ERROR: 1440 | self.bar += 'x' 1441 | vim.command("call add(s:update.errors, '{0}')".format(name)) 1442 | elif action == Action.DONE: 1443 | self.bar += '=' 1444 | 1445 | curbuf = vim.current.buffer 1446 | lnum = self.__where(name) 1447 | if lnum != -1: # Found matching line num 1448 | del curbuf[lnum] 1449 | if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]): 1450 | lnum = 3 1451 | else: 1452 | lnum = 3 1453 | curbuf.append(msg, lnum) 1454 | 1455 | self.header() 1456 | except vim.error: 1457 | pass 1458 | 1459 | class Command(object): 1460 | CD = 'cd /d' if G_IS_WIN else 'cd' 1461 | 1462 | def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None): 1463 | self.cmd = cmd 1464 | if cmd_dir: 1465 | self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd) 1466 | self.timeout = timeout 1467 | self.callback = cb if cb else (lambda msg: None) 1468 | self.clean = clean if clean else (lambda: None) 1469 | self.proc = None 1470 | 1471 | @property 1472 | def alive(self): 1473 | """ Returns true only if command still running. """ 1474 | return self.proc and self.proc.poll() is None 1475 | 1476 | def execute(self, ntries=3): 1477 | """ Execute the command with ntries if CmdTimedOut. 1478 | Returns the output of the command if no Exception. 1479 | """ 1480 | attempt, finished, limit = 0, False, self.timeout 1481 | 1482 | while not finished: 1483 | try: 1484 | attempt += 1 1485 | result = self.try_command() 1486 | finished = True 1487 | return result 1488 | except CmdTimedOut: 1489 | if attempt != ntries: 1490 | self.notify_retry() 1491 | self.timeout += limit 1492 | else: 1493 | raise 1494 | 1495 | def notify_retry(self): 1496 | """ Retry required for command, notify user. """ 1497 | for count in range(3, 0, -1): 1498 | if G_STOP.is_set(): 1499 | raise KeyboardInterrupt 1500 | msg = 'Timeout. Will retry in {0} second{1} ...'.format( 1501 | count, 's' if count != 1 else '') 1502 | self.callback([msg]) 1503 | time.sleep(1) 1504 | self.callback(['Retrying ...']) 1505 | 1506 | def try_command(self): 1507 | """ Execute a cmd & poll for callback. Returns list of output. 1508 | Raises CmdFailed -> return code for Popen isn't 0 1509 | Raises CmdTimedOut -> command exceeded timeout without new output 1510 | """ 1511 | first_line = True 1512 | 1513 | try: 1514 | tfile = tempfile.NamedTemporaryFile(mode='w+b') 1515 | preexec_fn = not G_IS_WIN and os.setsid or None 1516 | self.proc = subprocess.Popen(self.cmd, stdout=tfile, 1517 | stderr=subprocess.STDOUT, 1518 | stdin=subprocess.PIPE, shell=True, 1519 | preexec_fn=preexec_fn) 1520 | thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,)) 1521 | thrd.start() 1522 | 1523 | thread_not_started = True 1524 | while thread_not_started: 1525 | try: 1526 | thrd.join(0.1) 1527 | thread_not_started = False 1528 | except RuntimeError: 1529 | pass 1530 | 1531 | while self.alive: 1532 | if G_STOP.is_set(): 1533 | raise KeyboardInterrupt 1534 | 1535 | if first_line or random.random() < G_LOG_PROB: 1536 | first_line = False 1537 | line = '' if G_IS_WIN else nonblock_read(tfile.name) 1538 | if line: 1539 | self.callback([line]) 1540 | 1541 | time_diff = time.time() - os.path.getmtime(tfile.name) 1542 | if time_diff > self.timeout: 1543 | raise CmdTimedOut(['Timeout!']) 1544 | 1545 | thrd.join(0.5) 1546 | 1547 | tfile.seek(0) 1548 | result = [line.decode('utf-8', 'replace').rstrip() for line in tfile] 1549 | 1550 | if self.proc.returncode != 0: 1551 | raise CmdFailed([''] + result) 1552 | 1553 | return result 1554 | except: 1555 | self.terminate() 1556 | raise 1557 | 1558 | def terminate(self): 1559 | """ Terminate process and cleanup. """ 1560 | if self.alive: 1561 | if G_IS_WIN: 1562 | os.kill(self.proc.pid, signal.SIGINT) 1563 | else: 1564 | os.killpg(self.proc.pid, signal.SIGTERM) 1565 | self.clean() 1566 | 1567 | class Plugin(object): 1568 | def __init__(self, name, args, buf_q, lock): 1569 | self.name = name 1570 | self.args = args 1571 | self.buf_q = buf_q 1572 | self.lock = lock 1573 | self.tag = args.get('tag', 0) 1574 | 1575 | def manage(self): 1576 | try: 1577 | if os.path.exists(self.args['dir']): 1578 | self.update() 1579 | else: 1580 | self.install() 1581 | with self.lock: 1582 | thread_vim_command("let s:update.new['{0}'] = 1".format(self.name)) 1583 | except PlugError as exc: 1584 | self.write(Action.ERROR, self.name, exc.msg) 1585 | except KeyboardInterrupt: 1586 | G_STOP.set() 1587 | self.write(Action.ERROR, self.name, ['Interrupted!']) 1588 | except: 1589 | # Any exception except those above print stack trace 1590 | msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip()) 1591 | self.write(Action.ERROR, self.name, msg.split('\n')) 1592 | raise 1593 | 1594 | def install(self): 1595 | target = self.args['dir'] 1596 | if target[-1] == '\\': 1597 | target = target[0:-1] 1598 | 1599 | def clean(target): 1600 | def _clean(): 1601 | try: 1602 | shutil.rmtree(target) 1603 | except OSError: 1604 | pass 1605 | return _clean 1606 | 1607 | self.write(Action.INSTALL, self.name, ['Installing ...']) 1608 | callback = functools.partial(self.write, Action.INSTALL, self.name) 1609 | cmd = 'git clone {0} {1} {2} {3} 2>&1'.format( 1610 | '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'], 1611 | esc(target)) 1612 | com = Command(cmd, None, G_TIMEOUT, callback, clean(target)) 1613 | result = com.execute(G_RETRIES) 1614 | self.write(Action.DONE, self.name, result[-1:]) 1615 | 1616 | def repo_uri(self): 1617 | cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url' 1618 | command = Command(cmd, self.args['dir'], G_TIMEOUT,) 1619 | result = command.execute(G_RETRIES) 1620 | return result[-1] 1621 | 1622 | def update(self): 1623 | actual_uri = self.repo_uri() 1624 | expect_uri = self.args['uri'] 1625 | regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$') 1626 | ma = regex.match(actual_uri) 1627 | mb = regex.match(expect_uri) 1628 | if ma is None or mb is None or ma.groups() != mb.groups(): 1629 | msg = ['', 1630 | 'Invalid URI: {0}'.format(actual_uri), 1631 | 'Expected {0}'.format(expect_uri), 1632 | 'PlugClean required.'] 1633 | raise InvalidURI(msg) 1634 | 1635 | if G_PULL: 1636 | self.write(Action.UPDATE, self.name, ['Updating ...']) 1637 | callback = functools.partial(self.write, Action.UPDATE, self.name) 1638 | fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else '' 1639 | cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS) 1640 | com = Command(cmd, self.args['dir'], G_TIMEOUT, callback) 1641 | result = com.execute(G_RETRIES) 1642 | self.write(Action.DONE, self.name, result[-1:]) 1643 | else: 1644 | self.write(Action.DONE, self.name, ['Already installed']) 1645 | 1646 | def write(self, action, name, msg): 1647 | self.buf_q.put((action, name, msg)) 1648 | 1649 | class PlugThread(thr.Thread): 1650 | def __init__(self, tname, args): 1651 | super(PlugThread, self).__init__() 1652 | self.tname = tname 1653 | self.args = args 1654 | 1655 | def run(self): 1656 | thr.current_thread().name = self.tname 1657 | buf_q, work_q, lock = self.args 1658 | 1659 | try: 1660 | while not G_STOP.is_set(): 1661 | name, args = work_q.get_nowait() 1662 | plug = Plugin(name, args, buf_q, lock) 1663 | plug.manage() 1664 | work_q.task_done() 1665 | except queue.Empty: 1666 | pass 1667 | 1668 | class RefreshThread(thr.Thread): 1669 | def __init__(self, lock): 1670 | super(RefreshThread, self).__init__() 1671 | self.lock = lock 1672 | self.running = True 1673 | 1674 | def run(self): 1675 | while self.running: 1676 | with self.lock: 1677 | thread_vim_command('noautocmd normal! a') 1678 | time.sleep(0.33) 1679 | 1680 | def stop(self): 1681 | self.running = False 1682 | 1683 | if G_NVIM: 1684 | def thread_vim_command(cmd): 1685 | vim.session.threadsafe_call(lambda: vim.command(cmd)) 1686 | else: 1687 | def thread_vim_command(cmd): 1688 | vim.command(cmd) 1689 | 1690 | def esc(name): 1691 | return '"' + name.replace('"', '\"') + '"' 1692 | 1693 | def nonblock_read(fname): 1694 | """ Read a file with nonblock flag. Return the last line. """ 1695 | fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK) 1696 | buf = os.read(fread, 100000).decode('utf-8', 'replace') 1697 | os.close(fread) 1698 | 1699 | line = buf.rstrip('\r\n') 1700 | left = max(line.rfind('\r'), line.rfind('\n')) 1701 | if left != -1: 1702 | left += 1 1703 | line = line[left:] 1704 | 1705 | return line 1706 | 1707 | def main(): 1708 | thr.current_thread().name = 'main' 1709 | nthreads = int(vim.eval('s:update.threads')) 1710 | plugs = vim.eval('s:update.todo') 1711 | mac_gui = vim.eval('s:mac_gui') == '1' 1712 | 1713 | lock = thr.Lock() 1714 | buf = Buffer(lock, len(plugs), G_PULL) 1715 | buf_q, work_q = queue.Queue(), queue.Queue() 1716 | for work in plugs.items(): 1717 | work_q.put(work) 1718 | 1719 | start_cnt = thr.active_count() 1720 | for num in range(nthreads): 1721 | tname = 'PlugT-{0:02}'.format(num) 1722 | thread = PlugThread(tname, (buf_q, work_q, lock)) 1723 | thread.start() 1724 | if mac_gui: 1725 | rthread = RefreshThread(lock) 1726 | rthread.start() 1727 | 1728 | while not buf_q.empty() or thr.active_count() != start_cnt: 1729 | try: 1730 | action, name, msg = buf_q.get(True, 0.25) 1731 | buf.write(action, name, ['OK'] if not msg else msg) 1732 | buf_q.task_done() 1733 | except queue.Empty: 1734 | pass 1735 | except KeyboardInterrupt: 1736 | G_STOP.set() 1737 | 1738 | if mac_gui: 1739 | rthread.stop() 1740 | rthread.join() 1741 | 1742 | main() 1743 | EOF 1744 | endfunction 1745 | 1746 | function! s:update_ruby() 1747 | ruby << EOF 1748 | module PlugStream 1749 | SEP = ["\r", "\n", nil] 1750 | def get_line 1751 | buffer = '' 1752 | loop do 1753 | char = readchar rescue return 1754 | if SEP.include? char.chr 1755 | buffer << $/ 1756 | break 1757 | else 1758 | buffer << char 1759 | end 1760 | end 1761 | buffer 1762 | end 1763 | end unless defined?(PlugStream) 1764 | 1765 | def esc arg 1766 | %["#{arg.gsub('"', '\"')}"] 1767 | end 1768 | 1769 | def killall pid 1770 | pids = [pid] 1771 | if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM 1772 | pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil } 1773 | else 1774 | unless `which pgrep 2> /dev/null`.empty? 1775 | children = pids 1776 | until children.empty? 1777 | children = children.map { |pid| 1778 | `pgrep -P #{pid}`.lines.map { |l| l.chomp } 1779 | }.flatten 1780 | pids += children 1781 | end 1782 | end 1783 | pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil } 1784 | end 1785 | end 1786 | 1787 | def compare_git_uri a, b 1788 | regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$} 1789 | regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1) 1790 | end 1791 | 1792 | require 'thread' 1793 | require 'fileutils' 1794 | require 'timeout' 1795 | running = true 1796 | iswin = VIM::evaluate('s:is_win').to_i == 1 1797 | pull = VIM::evaluate('s:update.pull').to_i == 1 1798 | base = VIM::evaluate('g:plug_home') 1799 | all = VIM::evaluate('s:update.todo') 1800 | limit = VIM::evaluate('get(g:, "plug_timeout", 60)') 1801 | tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1 1802 | nthr = VIM::evaluate('s:update.threads').to_i 1803 | maxy = VIM::evaluate('winheight(".")').to_i 1804 | vim7 = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/ 1805 | cd = iswin ? 'cd /d' : 'cd' 1806 | tot = VIM::evaluate('len(s:update.todo)') || 0 1807 | bar = '' 1808 | skip = 'Already installed' 1809 | mtx = Mutex.new 1810 | take1 = proc { mtx.synchronize { running && all.shift } } 1811 | logh = proc { 1812 | cnt = bar.length 1813 | $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})" 1814 | $curbuf[2] = '[' + bar.ljust(tot) + ']' 1815 | VIM::command('normal! 2G') 1816 | VIM::command('redraw') 1817 | } 1818 | where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } } 1819 | log = proc { |name, result, type| 1820 | mtx.synchronize do 1821 | ing = ![true, false].include?(type) 1822 | bar += type ? '=' : 'x' unless ing 1823 | b = case type 1824 | when :install then '+' when :update then '*' 1825 | when true, nil then '-' else 1826 | VIM::command("call add(s:update.errors, '#{name}')") 1827 | 'x' 1828 | end 1829 | result = 1830 | if type || type.nil? 1831 | ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"] 1832 | elsif result =~ /^Interrupted|^Timeout/ 1833 | ["#{b} #{name}: #{result}"] 1834 | else 1835 | ["#{b} #{name}"] + result.lines.map { |l| " " << l } 1836 | end 1837 | if lnum = where.call(name) 1838 | $curbuf.delete lnum 1839 | lnum = 4 if ing && lnum > maxy 1840 | end 1841 | result.each_with_index do |line, offset| 1842 | $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp) 1843 | end 1844 | logh.call 1845 | end 1846 | } 1847 | bt = proc { |cmd, name, type, cleanup| 1848 | tried = timeout = 0 1849 | begin 1850 | tried += 1 1851 | timeout += limit 1852 | fd = nil 1853 | data = '' 1854 | if iswin 1855 | Timeout::timeout(timeout) do 1856 | tmp = VIM::evaluate('tempname()') 1857 | system("(#{cmd}) > #{tmp}") 1858 | data = File.read(tmp).chomp 1859 | File.unlink tmp rescue nil 1860 | end 1861 | else 1862 | fd = IO.popen(cmd).extend(PlugStream) 1863 | first_line = true 1864 | log_prob = 1.0 / nthr 1865 | while line = Timeout::timeout(timeout) { fd.get_line } 1866 | data << line 1867 | log.call name, line.chomp, type if name && (first_line || rand < log_prob) 1868 | first_line = false 1869 | end 1870 | fd.close 1871 | end 1872 | [$? == 0, data.chomp] 1873 | rescue Timeout::Error, Interrupt => e 1874 | if fd && !fd.closed? 1875 | killall fd.pid 1876 | fd.close 1877 | end 1878 | cleanup.call if cleanup 1879 | if e.is_a?(Timeout::Error) && tried < tries 1880 | 3.downto(1) do |countdown| 1881 | s = countdown > 1 ? 's' : '' 1882 | log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type 1883 | sleep 1 1884 | end 1885 | log.call name, 'Retrying ...', type 1886 | retry 1887 | end 1888 | [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"] 1889 | end 1890 | } 1891 | main = Thread.current 1892 | threads = [] 1893 | watcher = Thread.new { 1894 | if vim7 1895 | while VIM::evaluate('getchar(1)') 1896 | sleep 0.1 1897 | end 1898 | else 1899 | require 'io/console' # >= Ruby 1.9 1900 | nil until IO.console.getch == 3.chr 1901 | end 1902 | mtx.synchronize do 1903 | running = false 1904 | threads.each { |t| t.raise Interrupt } unless vim7 1905 | end 1906 | threads.each { |t| t.join rescue nil } 1907 | main.kill 1908 | } 1909 | refresh = Thread.new { 1910 | while true 1911 | mtx.synchronize do 1912 | break unless running 1913 | VIM::command('noautocmd normal! a') 1914 | end 1915 | sleep 0.2 1916 | end 1917 | } if VIM::evaluate('s:mac_gui') == 1 1918 | 1919 | clone_opt = VIM::evaluate('s:clone_opt') 1920 | progress = VIM::evaluate('s:progress_opt(1)') 1921 | nthr.times do 1922 | mtx.synchronize do 1923 | threads << Thread.new { 1924 | while pair = take1.call 1925 | name = pair.first 1926 | dir, uri, tag = pair.last.values_at *%w[dir uri tag] 1927 | exists = File.directory? dir 1928 | ok, result = 1929 | if exists 1930 | chdir = "#{cd} #{iswin ? dir : esc(dir)}" 1931 | ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil 1932 | current_uri = data.lines.to_a.last 1933 | if !ret 1934 | if data =~ /^Interrupted|^Timeout/ 1935 | [false, data] 1936 | else 1937 | [false, [data.chomp, "PlugClean required."].join($/)] 1938 | end 1939 | elsif !compare_git_uri(current_uri, uri) 1940 | [false, ["Invalid URI: #{current_uri}", 1941 | "Expected: #{uri}", 1942 | "PlugClean required."].join($/)] 1943 | else 1944 | if pull 1945 | log.call name, 'Updating ...', :update 1946 | fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : '' 1947 | bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil 1948 | else 1949 | [true, skip] 1950 | end 1951 | end 1952 | else 1953 | d = esc dir.sub(%r{[\\/]+$}, '') 1954 | log.call name, 'Installing ...', :install 1955 | bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc { 1956 | FileUtils.rm_rf dir 1957 | } 1958 | end 1959 | mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok 1960 | log.call name, result, ok 1961 | end 1962 | } if running 1963 | end 1964 | end 1965 | threads.each { |t| t.join rescue nil } 1966 | logh.call 1967 | refresh.kill if refresh 1968 | watcher.kill 1969 | EOF 1970 | endfunction 1971 | 1972 | function! s:shellesc_cmd(arg) 1973 | let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g') 1974 | let escaped = substitute(escaped, '%', '%%', 'g') 1975 | let escaped = substitute(escaped, '"', '\\^&', 'g') 1976 | let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g') 1977 | return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"' 1978 | endfunction 1979 | 1980 | function! s:shellesc(arg) 1981 | if &shell =~# 'cmd.exe$' 1982 | return s:shellesc_cmd(a:arg) 1983 | endif 1984 | return shellescape(a:arg) 1985 | endfunction 1986 | 1987 | function! s:glob_dir(path) 1988 | return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)') 1989 | endfunction 1990 | 1991 | function! s:progress_bar(line, bar, total) 1992 | call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']') 1993 | endfunction 1994 | 1995 | function! s:compare_git_uri(a, b) 1996 | " See `git help clone' 1997 | " https:// [user@] github.com[:port] / junegunn/vim-plug [.git] 1998 | " [git@] github.com[:port] : junegunn/vim-plug [.git] 1999 | " file:// / junegunn/vim-plug [/] 2000 | " / junegunn/vim-plug [/] 2001 | let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$' 2002 | let ma = matchlist(a:a, pat) 2003 | let mb = matchlist(a:b, pat) 2004 | return ma[1:2] ==# mb[1:2] 2005 | endfunction 2006 | 2007 | function! s:format_message(bullet, name, message) 2008 | if a:bullet != 'x' 2009 | return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))] 2010 | else 2011 | let lines = map(s:lines(a:message), '" ".v:val') 2012 | return extend([printf('x %s:', a:name)], lines) 2013 | endif 2014 | endfunction 2015 | 2016 | function! s:with_cd(cmd, dir) 2017 | return printf('cd%s %s && %s', s:is_win ? ' /d' : '', s:shellesc(a:dir), a:cmd) 2018 | endfunction 2019 | 2020 | function! s:system(cmd, ...) 2021 | try 2022 | let [sh, shellcmdflag, shrd] = s:chsh(1) 2023 | let cmd = a:0 > 0 ? s:with_cd(a:cmd, a:1) : a:cmd 2024 | if s:is_win 2025 | let batchfile = tempname().'.bat' 2026 | call writefile(['@echo off', cmd], batchfile) 2027 | let cmd = batchfile 2028 | endif 2029 | return system(s:is_win ? '('.cmd.')' : cmd) 2030 | finally 2031 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] 2032 | if s:is_win 2033 | call delete(batchfile) 2034 | endif 2035 | endtry 2036 | endfunction 2037 | 2038 | function! s:system_chomp(...) 2039 | let ret = call('s:system', a:000) 2040 | return v:shell_error ? '' : substitute(ret, '\n$', '', '') 2041 | endfunction 2042 | 2043 | function! s:git_validate(spec, check_branch) 2044 | let err = '' 2045 | if isdirectory(a:spec.dir) 2046 | 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)) 2047 | let remote = result[-1] 2048 | if v:shell_error 2049 | let err = join([remote, 'PlugClean required.'], "\n") 2050 | elseif !s:compare_git_uri(remote, a:spec.uri) 2051 | let err = join(['Invalid URI: '.remote, 2052 | \ 'Expected: '.a:spec.uri, 2053 | \ 'PlugClean required.'], "\n") 2054 | elseif a:check_branch && has_key(a:spec, 'commit') 2055 | let result = s:lines(s:system('git rev-parse HEAD 2>&1', a:spec.dir)) 2056 | let sha = result[-1] 2057 | if v:shell_error 2058 | let err = join(add(result, 'PlugClean required.'), "\n") 2059 | elseif !s:hash_match(sha, a:spec.commit) 2060 | let err = join([printf('Invalid HEAD (expected: %s, actual: %s)', 2061 | \ a:spec.commit[:6], sha[:6]), 2062 | \ 'PlugUpdate required.'], "\n") 2063 | endif 2064 | elseif a:check_branch 2065 | let branch = result[0] 2066 | " Check tag 2067 | if has_key(a:spec, 'tag') 2068 | let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir) 2069 | if a:spec.tag !=# tag && a:spec.tag !~ '\*' 2070 | let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.', 2071 | \ (empty(tag) ? 'N/A' : tag), a:spec.tag) 2072 | endif 2073 | " Check branch 2074 | elseif a:spec.branch !=# branch 2075 | let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.', 2076 | \ branch, a:spec.branch) 2077 | endif 2078 | if empty(err) 2079 | let [ahead, behind] = split(s:lastline(s:system(printf( 2080 | \ 'git rev-list --count --left-right HEAD...origin/%s', 2081 | \ a:spec.branch), a:spec.dir)), '\t') 2082 | if !v:shell_error && ahead 2083 | if behind 2084 | " Only mention PlugClean if diverged, otherwise it's likely to be 2085 | " pushable (and probably not that messed up). 2086 | let err = printf( 2087 | \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n" 2088 | \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', a:spec.branch, ahead, behind) 2089 | else 2090 | let err = printf("Ahead of origin/%s by %d commit(s).\n" 2091 | \ .'Cannot update until local changes are pushed.', 2092 | \ a:spec.branch, ahead) 2093 | endif 2094 | endif 2095 | endif 2096 | endif 2097 | else 2098 | let err = 'Not found' 2099 | endif 2100 | return [err, err =~# 'PlugClean'] 2101 | endfunction 2102 | 2103 | function! s:rm_rf(dir) 2104 | if isdirectory(a:dir) 2105 | call s:system((s:is_win ? 'rmdir /S /Q ' : 'rm -rf ') . s:shellesc(a:dir)) 2106 | endif 2107 | endfunction 2108 | 2109 | function! s:clean(force) 2110 | call s:prepare() 2111 | call append(0, 'Searching for invalid plugins in '.g:plug_home) 2112 | call append(1, '') 2113 | 2114 | " List of valid directories 2115 | let dirs = [] 2116 | let errs = {} 2117 | let [cnt, total] = [0, len(g:plugs)] 2118 | for [name, spec] in items(g:plugs) 2119 | if !s:is_managed(name) 2120 | call add(dirs, spec.dir) 2121 | else 2122 | let [err, clean] = s:git_validate(spec, 1) 2123 | if clean 2124 | let errs[spec.dir] = s:lines(err)[0] 2125 | else 2126 | call add(dirs, spec.dir) 2127 | endif 2128 | endif 2129 | let cnt += 1 2130 | call s:progress_bar(2, repeat('=', cnt), total) 2131 | normal! 2G 2132 | redraw 2133 | endfor 2134 | 2135 | let allowed = {} 2136 | for dir in dirs 2137 | let allowed[s:dirpath(fnamemodify(dir, ':h:h'))] = 1 2138 | let allowed[dir] = 1 2139 | for child in s:glob_dir(dir) 2140 | let allowed[child] = 1 2141 | endfor 2142 | endfor 2143 | 2144 | let todo = [] 2145 | let found = sort(s:glob_dir(g:plug_home)) 2146 | while !empty(found) 2147 | let f = remove(found, 0) 2148 | if !has_key(allowed, f) && isdirectory(f) 2149 | call add(todo, f) 2150 | call append(line('$'), '- ' . f) 2151 | if has_key(errs, f) 2152 | call append(line('$'), ' ' . errs[f]) 2153 | endif 2154 | let found = filter(found, 'stridx(v:val, f) != 0') 2155 | end 2156 | endwhile 2157 | 2158 | 4 2159 | redraw 2160 | if empty(todo) 2161 | call append(line('$'), 'Already clean.') 2162 | else 2163 | let s:clean_count = 0 2164 | call append(3, ['Directories to delete:', '']) 2165 | redraw! 2166 | if a:force || s:ask_no_interrupt('Delete all directories?') 2167 | call s:delete([6, line('$')], 1) 2168 | else 2169 | call setline(4, 'Cancelled.') 2170 | nnoremap d :set opfunc=delete_opg@ 2171 | nmap dd d_ 2172 | xnoremap d :call delete_op(visualmode(), 1) 2173 | echo 'Delete the lines (d{motion}) to delete the corresponding directories' 2174 | endif 2175 | endif 2176 | 4 2177 | setlocal nomodifiable 2178 | endfunction 2179 | 2180 | function! s:delete_op(type, ...) 2181 | call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0) 2182 | endfunction 2183 | 2184 | function! s:delete(range, force) 2185 | let [l1, l2] = a:range 2186 | let force = a:force 2187 | while l1 <= l2 2188 | let line = getline(l1) 2189 | if line =~ '^- ' && isdirectory(line[2:]) 2190 | execute l1 2191 | redraw! 2192 | let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1) 2193 | let force = force || answer > 1 2194 | if answer 2195 | call s:rm_rf(line[2:]) 2196 | setlocal modifiable 2197 | call setline(l1, '~'.line[1:]) 2198 | let s:clean_count += 1 2199 | call setline(4, printf('Removed %d directories.', s:clean_count)) 2200 | setlocal nomodifiable 2201 | endif 2202 | endif 2203 | let l1 += 1 2204 | endwhile 2205 | endfunction 2206 | 2207 | function! s:upgrade() 2208 | echo 'Downloading the latest version of vim-plug' 2209 | redraw 2210 | let tmp = tempname() 2211 | let new = tmp . '/plug.vim' 2212 | 2213 | try 2214 | let out = s:system(printf('git clone --depth 1 %s %s', s:plug_src, tmp)) 2215 | if v:shell_error 2216 | return s:err('Error upgrading vim-plug: '. out) 2217 | endif 2218 | 2219 | if readfile(s:me) ==# readfile(new) 2220 | echo 'vim-plug is already up-to-date' 2221 | return 0 2222 | else 2223 | call rename(s:me, s:me . '.old') 2224 | call rename(new, s:me) 2225 | unlet g:loaded_plug 2226 | echo 'vim-plug has been upgraded' 2227 | return 1 2228 | endif 2229 | finally 2230 | silent! call s:rm_rf(tmp) 2231 | endtry 2232 | endfunction 2233 | 2234 | function! s:upgrade_specs() 2235 | for spec in values(g:plugs) 2236 | let spec.frozen = get(spec, 'frozen', 0) 2237 | endfor 2238 | endfunction 2239 | 2240 | function! s:status() 2241 | call s:prepare() 2242 | call append(0, 'Checking plugins') 2243 | call append(1, '') 2244 | 2245 | let ecnt = 0 2246 | let unloaded = 0 2247 | let [cnt, total] = [0, len(g:plugs)] 2248 | for [name, spec] in items(g:plugs) 2249 | let is_dir = isdirectory(spec.dir) 2250 | if has_key(spec, 'uri') 2251 | if is_dir 2252 | let [err, _] = s:git_validate(spec, 1) 2253 | let [valid, msg] = [empty(err), empty(err) ? 'OK' : err] 2254 | else 2255 | let [valid, msg] = [0, 'Not found. Try PlugInstall.'] 2256 | endif 2257 | else 2258 | if is_dir 2259 | let [valid, msg] = [1, 'OK'] 2260 | else 2261 | let [valid, msg] = [0, 'Not found.'] 2262 | endif 2263 | endif 2264 | let cnt += 1 2265 | let ecnt += !valid 2266 | " `s:loaded` entry can be missing if PlugUpgraded 2267 | if is_dir && get(s:loaded, name, -1) == 0 2268 | let unloaded = 1 2269 | let msg .= ' (not loaded)' 2270 | endif 2271 | call s:progress_bar(2, repeat('=', cnt), total) 2272 | call append(3, s:format_message(valid ? '-' : 'x', name, msg)) 2273 | normal! 2G 2274 | redraw 2275 | endfor 2276 | call setline(1, 'Finished. '.ecnt.' error(s).') 2277 | normal! gg 2278 | setlocal nomodifiable 2279 | if unloaded 2280 | echo "Press 'L' on each line to load plugin, or 'U' to update" 2281 | nnoremap L :call status_load(line('.')) 2282 | xnoremap L :call status_load(line('.')) 2283 | end 2284 | endfunction 2285 | 2286 | function! s:extract_name(str, prefix, suffix) 2287 | return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$') 2288 | endfunction 2289 | 2290 | function! s:status_load(lnum) 2291 | let line = getline(a:lnum) 2292 | let name = s:extract_name(line, '-', '(not loaded)') 2293 | if !empty(name) 2294 | call plug#load(name) 2295 | setlocal modifiable 2296 | call setline(a:lnum, substitute(line, ' (not loaded)$', '', '')) 2297 | setlocal nomodifiable 2298 | endif 2299 | endfunction 2300 | 2301 | function! s:status_update() range 2302 | let lines = getline(a:firstline, a:lastline) 2303 | let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)') 2304 | if !empty(names) 2305 | echo 2306 | execute 'PlugUpdate' join(names) 2307 | endif 2308 | endfunction 2309 | 2310 | function! s:is_preview_window_open() 2311 | silent! wincmd P 2312 | if &previewwindow 2313 | wincmd p 2314 | return 1 2315 | endif 2316 | endfunction 2317 | 2318 | function! s:find_name(lnum) 2319 | for lnum in reverse(range(1, a:lnum)) 2320 | let line = getline(lnum) 2321 | if empty(line) 2322 | return '' 2323 | endif 2324 | let name = s:extract_name(line, '-', '') 2325 | if !empty(name) 2326 | return name 2327 | endif 2328 | endfor 2329 | return '' 2330 | endfunction 2331 | 2332 | function! s:preview_commit() 2333 | if b:plug_preview < 0 2334 | let b:plug_preview = !s:is_preview_window_open() 2335 | endif 2336 | 2337 | let sha = matchstr(getline('.'), '^ \X*\zs[0-9a-f]\{7,9}') 2338 | if empty(sha) 2339 | return 2340 | endif 2341 | 2342 | let name = s:find_name(line('.')) 2343 | if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir) 2344 | return 2345 | endif 2346 | 2347 | if exists('g:plug_pwindow') && !s:is_preview_window_open() 2348 | execute g:plug_pwindow 2349 | execute 'e' sha 2350 | else 2351 | execute 'pedit' sha 2352 | wincmd P 2353 | endif 2354 | setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable 2355 | try 2356 | let [sh, shellcmdflag, shrd] = s:chsh(1) 2357 | let cmd = 'cd '.s:shellesc(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha 2358 | if s:is_win 2359 | let batchfile = tempname().'.bat' 2360 | call writefile(['@echo off', cmd], batchfile) 2361 | let cmd = batchfile 2362 | endif 2363 | execute 'silent %!' cmd 2364 | finally 2365 | let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd] 2366 | if s:is_win 2367 | call delete(batchfile) 2368 | endif 2369 | endtry 2370 | setlocal nomodifiable 2371 | nnoremap q :q 2372 | wincmd p 2373 | endfunction 2374 | 2375 | function! s:section(flags) 2376 | call search('\(^[x-] \)\@<=[^:]\+:', a:flags) 2377 | endfunction 2378 | 2379 | function! s:format_git_log(line) 2380 | let indent = ' ' 2381 | let tokens = split(a:line, nr2char(1)) 2382 | if len(tokens) != 5 2383 | return indent.substitute(a:line, '\s*$', '', '') 2384 | endif 2385 | let [graph, sha, refs, subject, date] = tokens 2386 | let tag = matchstr(refs, 'tag: [^,)]\+') 2387 | let tag = empty(tag) ? ' ' : ' ('.tag.') ' 2388 | return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date) 2389 | endfunction 2390 | 2391 | function! s:append_ul(lnum, text) 2392 | call append(a:lnum, ['', a:text, repeat('-', len(a:text))]) 2393 | endfunction 2394 | 2395 | function! s:diff() 2396 | call s:prepare() 2397 | call append(0, ['Collecting changes ...', '']) 2398 | let cnts = [0, 0] 2399 | let bar = '' 2400 | let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)') 2401 | call s:progress_bar(2, bar, len(total)) 2402 | for origin in [1, 0] 2403 | let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))')))) 2404 | if empty(plugs) 2405 | continue 2406 | endif 2407 | call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:') 2408 | for [k, v] in plugs 2409 | let range = origin ? '..origin/'.v.branch : 'HEAD@{1}..' 2410 | let diff = s:system_chomp('git log --graph --color=never '.join(map(['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range], 's:shellesc(v:val)')), v.dir) 2411 | if !empty(diff) 2412 | let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : '' 2413 | call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)'))) 2414 | let cnts[origin] += 1 2415 | endif 2416 | let bar .= '=' 2417 | call s:progress_bar(2, bar, len(total)) 2418 | normal! 2G 2419 | redraw 2420 | endfor 2421 | if !cnts[origin] 2422 | call append(5, ['', 'N/A']) 2423 | endif 2424 | endfor 2425 | call setline(1, printf('%d plugin(s) updated.', cnts[0]) 2426 | \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : '')) 2427 | 2428 | if cnts[0] || cnts[1] 2429 | nnoremap :silent! call preview_commit() 2430 | nnoremap o :silent! call preview_commit() 2431 | endif 2432 | if cnts[0] 2433 | nnoremap X :call revert() 2434 | echo "Press 'X' on each block to revert the update" 2435 | endif 2436 | normal! gg 2437 | setlocal nomodifiable 2438 | endfunction 2439 | 2440 | function! s:revert() 2441 | if search('^Pending updates', 'bnW') 2442 | return 2443 | endif 2444 | 2445 | let name = s:find_name(line('.')) 2446 | if empty(name) || !has_key(g:plugs, name) || 2447 | \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y' 2448 | return 2449 | endif 2450 | 2451 | call s:system('git reset --hard HEAD@{1} && git checkout '.s:esc(g:plugs[name].branch).' --', g:plugs[name].dir) 2452 | setlocal modifiable 2453 | normal! "_dap 2454 | setlocal nomodifiable 2455 | echo 'Reverted' 2456 | endfunction 2457 | 2458 | function! s:snapshot(force, ...) abort 2459 | call s:prepare() 2460 | setf vim 2461 | call append(0, ['" Generated by vim-plug', 2462 | \ '" '.strftime("%c"), 2463 | \ '" :source this file in vim to restore the snapshot', 2464 | \ '" or execute: vim -S snapshot.vim', 2465 | \ '', '', 'PlugUpdate!']) 2466 | 1 2467 | let anchor = line('$') - 3 2468 | let names = sort(keys(filter(copy(g:plugs), 2469 | \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)'))) 2470 | for name in reverse(names) 2471 | let sha = s:system_chomp('git rev-parse --short HEAD', g:plugs[name].dir) 2472 | if !empty(sha) 2473 | call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha)) 2474 | redraw 2475 | endif 2476 | endfor 2477 | 2478 | if a:0 > 0 2479 | let fn = expand(a:1) 2480 | if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?')) 2481 | return 2482 | endif 2483 | call writefile(getline(1, '$'), fn) 2484 | echo 'Saved as '.a:1 2485 | silent execute 'e' s:esc(fn) 2486 | setf vim 2487 | endif 2488 | endfunction 2489 | 2490 | function! s:split_rtp() 2491 | return split(&rtp, '\\\@