.vimrc bug
set nocompatible " be iMproved, required | |
" ---------------------------------------------------------------------------- | |
" Vim SETTINGS | |
" ---------------------------------------------------------------------------- | |
syntax enable | |
let mapleader = ',' | |
set synmaxcol=400 | |
set mouse=n | |
set number | |
set relativenumber | |
set cursorline | |
set textwidth=0 | |
set pastetoggle=<F11> | |
set background=dark | |
set shortmess=filmnrwxtToO | |
set showcmd | |
set history=5000 | |
set backspace=indent,eol,start | |
set wrap | |
" Don't update the display while executing macros | |
set scrolloff=8 | |
set lazyredraw | |
set ignorecase | |
set smartcase | |
set autoread | |
set hlsearch | |
set incsearch | |
" Have a list when having completion | |
" http://stackoverflow.com/questions/704282/filename-completion-in-reverse-order | |
set wildmenu | |
set splitright | |
set splitbelow | |
set ttimeoutlen=0 | |
set listchars=tab:>-,trail:- | |
set list | |
" size of an "indent" | |
set shiftwidth=4 | |
" size of a hard tabstop | |
set tabstop=4 | |
" a combination of spaces and tabs are used to simulate tab stops at a width | |
" other than the (hard)tabstop | |
set softtabstop=4 | |
set expandtab | |
set noswapfile | |
set nobackup | |
set nowritebackup | |
if has('vim_starting') | |
set foldmethod=indent | |
endif | |
set guioptions-=m "remove menu bar | |
set guioptions-=T "remove toolbar | |
set guioptions-=r "remove right-hand scroll bar | |
set tags=./tags;/,tags;/ | |
set viminfo='100,<50,s10,h,f1 | |
set foldlevelstart=99 | |
let javaScript_fold=1 | |
" Use persistent undo | |
if has('persistent_undo') | |
" Save all undo files in a single location (less messy, more risky)... | |
set undodir=$HOME/tmp/.VIM_UNDO_FILES | |
" Save a lot of back-history... | |
set undolevels=5000 | |
" Actually switch on persistent undo | |
set undofile | |
endif | |
" Follow symlinks when opening a file | |
" NOTE: this happens with directory symlinks anyway (due to Vim's chdir/getcwd | |
" magic when getting filenames). | |
" Sources: | |
" - https://github.com/tpope/vim-fugitive/issues/147#issuecomment-7572351 | |
" - http://www.reddit.com/r/vim/comments/yhsn6/is_it_possible_to_work_around_the_symlink_bug/c5w91qw | |
function! MyFollowSymlink(...) | |
if exists('w:no_resolve_symlink') && w:no_resolve_symlink | |
return | |
endif | |
let fname = a:0 ? a:1 : expand('%') | |
if fname =~? '^\w\+:/' | |
" Do not mess with 'fugitive://' etc. | |
return | |
endif | |
let fname = simplify(fname) | |
let resolvedfile = resolve(fname) | |
if resolvedfile == fname | |
return | |
endif | |
let resolvedfile = fnameescape(resolvedfile) | |
let sshm = &shm | |
set shortmess+=A " silence ATTENTION message about swap file (would get displayed twice) | |
exec 'file ' . resolvedfile | |
exec 'w!' | |
let &shm=sshm | |
" Re-init fugitive. | |
silent! call fugitive#detect(resolvedfile) | |
if &modifiable | |
" Only display a note when editing a file, especially not for `:help`. | |
silent! redraw " Redraw now, to avoid hit-enter prompt. | |
echomsg 'Resolved symlink: =>' resolvedfile | |
redraw " Redraw now, to avoid hit-enter prompt. | |
endif | |
endfunction | |
command! FollowSymlink silent! call MyFollowSymlink() | |
command! ToggleFollowSymlink let w:no_resolve_symlink = !get(w:, 'no_resolve_symlink', 0) | echo "w:no_resolve_symlink =>" w:no_resolve_symlink | |
augroup followSymLinks | |
autocmd! | |
au BufReadPost * nested call MyFollowSymlink(expand('%')) | |
augroup END | |
" ---------------------------------------------------------------------------- | |
" Bundles | |
" ---------------------------------------------------------------------------- | |
" set the runtime path to include plug.vim | |
if has('vim_starting') | |
" Required: | |
source ~/.vim/autoload/plug.vim | |
endif | |
source ~/asynccommand.vim | |
set rtp+=~/.fzf | |
call plug#begin() | |
" Themes | |
Plug 'junegunn/seoul256.vim' | |
" Plug 'altercation/vim-colors-solarized' | |
" Plug 'flazz/vim-colorschemes' | |
" Utilities | |
Plug 'junegunn/goyo.vim', {'on': 'Goyo'} | |
Plug 'junegunn/fzf.vim' | |
Plug 'rking/ag.vim', {'on': 'Ag'} | |
Plug 'junegunn/vim-pseudocl' | |
Plug 'junegunn/vim-fnr' | |
Plug 'justinmk/vim-gtfo' | |
Plug 'majutsushi/tagbar' | |
Plug 'vim-scripts/ReplaceWithRegister' | |
Plug 'AndrewRadev/splitjoin.vim' | |
Plug 'junegunn/rainbow_parentheses.vim' | |
Plug 'junegunn/vim-after-object' | |
Plug 'osyo-manga/vim-over' | |
Plug 'AndrewRadev/splitjoin.vim' | |
" Plug 'tpope/vim-sensible' | |
Plug 'tpope/vim-unimpaired' | |
Plug 'Align', {'on': 'Align'} | |
Plug 'tommcdo/vim-exchange' | |
Plug 'scrooloose/syntastic' | |
Plug 'tpope/vim-fugitive' | |
Plug 'airblade/vim-gitgutter' | |
Plug 'mbbill/undotree', {'on': 'UndotreeToggle'} | |
Plug 'tpope/vim-commentary' | |
Plug 'tpope/vim-surround' | |
Plug 'airblade/vim-rooter' | |
Plug 'tpope/vim-dispatch' | |
Plug 'tpope/vim-repeat' | |
Plug 'honza/vim-snippets' | |
Plug 'tpope/vim-abolish' | |
Plug 'wellle/targets.vim' | |
Plug 'bogado/file-line' | |
Plug 'tpope/vim-vinegar' | |
Plug 'kassio/neoterm' | |
Plug 'vim-scripts/SearchComplete' | |
" Languages | |
Plug 'moorereason/vim-markdownfmt' | |
Plug 'tobyS/pdv' | |
Plug 'othree/html5.vim' | |
Plug 'moll/vim-node' | |
Plug 'elzr/vim-json' | |
Plug 'fatih/vim-go' | |
Plug 'avakhov/vim-yaml' | |
Plug 'vim-php/vim-php-refactoring' | |
Plug 'mattn/emmet-vim' | |
Plug 'tpope/vim-markdown' | |
Plug 'isRuslan/vim-es6' | |
Plug 'agirorn/vim-coloresque' | |
Plug 'hail2u/vim-css3-syntax' | |
Plug 'amirh/HTML-AutoCloseTag' | |
Plug 'kchmck/vim-coffee-script' | |
Plug 'ingydotnet/yaml-vim' | |
" For hunter | |
Plug 'mattn/webapi-vim' | |
Plug 'ogranada/hunter' | |
Plug 'benekastah/neomake' | |
Plug 'chip/vim-fat-finger' | |
if has('python') | |
Plug 'editorconfig/editorconfig-vim' | |
Plug 'SirVer/ultisnips' | |
endif | |
call plug#end() | |
" ---------------------------------------------------------------------------- | |
" Bundle configuration | |
" ---------------------------------------------------------------------------- | |
augroup rainbow | |
autocmd! | |
autocmd Filetype javascript,perl,vim silent! RainbowParentheses | |
augroup END | |
let g:rainbow#max_level = 16 | |
let g:rainbow#pairs = [['(', ')'], ['{', '}'], ['[', ']']] | |
let g:rainbow#colors = { | |
\ 'dark': [ | |
\ ['122' , '122' ] , | |
\ ['130' , '122' ] , | |
\ ['171' , '122' ] , | |
\ ['62' , '122' ] , | |
\ ['179' , '122' ] , | |
\ ['1' , '122' ] , | |
\ ['7' , '122' ] , | |
\ ['94' , '122' ] , | |
\ ['68' , '122' ] | |
\ ] , | |
\ 'light': [ | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] , | |
\ ['122' , '122' ] | |
\ ] | |
\ } | |
augroup Rainbow | |
autocmd! | |
autocmd VimEnter * silent! call after_object#enable([']', '['], '=', ':', '-', '#', ' ') | |
augroup END | |
" ----------- | |
if has('vim_starting') | |
set statusline+=%#warningmsg# | |
set statusline+=%{SyntasticStatuslineFlag()} | |
set statusline+=%* | |
endif | |
let g:markdownfmt_autosave=1 | |
" Use - for surrounding with ** | |
let g:surround_{char2nr("-")} = "**\r**" | |
let g:surround_{char2nr("+")} = "```\r```" | |
let g:ctrlp_open_new_file = 'r' | |
if isdirectory(expand('~/.$VIM_V/bundle/PIV')) | |
let g:DisableAutoPHPFolding = 0 | |
let g:PIVAutoClose = 0 | |
endif | |
let g:ackprg = 'ag --nogroup --nocolor --column' | |
let g:ack_use_dispatch=1 | |
let g:php_refactor_command='php ~/php-refactoring-browser/src/bin/refactor' | |
let g:UltiSnipsListSnippets='<c-l>' | |
let g:pdv_template_dir = $HOME .'/.templates_snip' | |
let g:gitgutter_map_keys = 0 | |
let g:gitgutter_sign_added = '+' | |
let g:gitgutter_sign_modified = '~~' | |
let g:gitgutter_sign_removed = '--' | |
let g:gitgutter_sign_removed_first_line = '--' | |
let g:gitgutter_sign_modified_removed = '-~' | |
let g:syntastic_always_populate_loc_list = 1 | |
let g:syntastic_auto_loc_list = 0 | |
let g:syntastic_check_on_open = 1 | |
let g:syntastic_check_on_wq = 1 | |
let g:syntastic_javascript_checkers = ['eslint'] | |
let g:syntastic_javascript_eslint_exec = 'jlint' | |
let g:neomake_javascript_eslint_exe = 'jlint' | |
let g:neomake_open_list = 2 | |
let g:syntastic_vim_checkers = ['vint'] | |
let g:rooter_disable_map = 1 | |
let g:multi_cursor_exit_from_insert_mode = 0 | |
highlight GitGutterAdd ctermbg=black | |
highlight GitGutterAdd ctermfg=green | |
highlight GitGutterChange ctermbg=grey | |
highlight GitGutterChange ctermfg=yellow | |
highlight GitGutterDelete ctermbg=white | |
highlight GitGutterDelete ctermfg=red | |
highlight GitGutterChangeDelete ctermbg=white | |
highlight GitGutterChangeDelete ctermfg=red | |
command! SynOff let g:syntastic_mode_map = { | |
\ "mode": "passive", | |
\ "active_filetypes": [], | |
\ "passive_filetypes": [] } | |
command! SynOn let g:syntastic_mode_map = { | |
\ "mode": "active", | |
\ "active_filetypes": [], | |
\ "passive_filetypes": [] } | |
SynOff | |
" ------------ | |
" Colorschemes | |
" ------------ | |
silent! colorscheme seoul256 | |
" colorscheme badwolf | |
" colorscheme Monokai | |
" colorscheme two2tango | |
" colorscheme freya | |
" colorscheme earendel | |
" colorscheme moria | |
" colorscheme github | |
" colorscheme codeschool | |
" colorscheme solarized | |
" ---------------------------------------------------------------------------- | |
" AgCommand | |
" ---------------------------------------------------------------------------- | |
function! s:ag_to_qf(line) | |
let parts = split(a:line, ':') | |
return {'filename': parts[0], 'lnum': parts[1], 'col': parts[2], | |
\ 'text': join(parts[3:], ':')} | |
endfunction | |
function! s:directory_opener(lines) | |
execute 'e '.a:lines[0] | |
execute 'only' | |
endfunction | |
nnoremap <silent> <C-j> :J<cr> | |
command! -nargs=* J call fzf#run({ | |
\ 'source': 'source ~/z.sh && _z -l 2>&1 | sed "s/[0-9\.]\+\s\+//" | sed "s@\$@/@"', | |
\ 'sink*': function('<sid>directory_opener'), | |
\ 'options': '--ansi '. | |
\ '--color hl:68,hl+:110', | |
\ 'down': '50%' | |
\ }) | |
function! s:ag_handler(lines) | |
if len(a:lines) < 2 | return | endif | |
let cmd = get({'ctrl-x': 'split', | |
\ 'ctrl-v': 'vertical split', | |
\ 'ctrl-t': 'tabe'}, a:lines[0], 'e') | |
let list = map(a:lines[1:], 's:ag_to_qf(v:val)') | |
let first = list[0] | |
execute cmd escape(first.filename, ' %#\') | |
execute first.lnum | |
execute 'normal!' first.col.'|zz' | |
if len(list) > 1 | |
call setqflist(list) | |
copen | |
wincmd p | |
endif | |
endfunction | |
command! -nargs=* A call fzf#run({ | |
\ 'source': printf('ag --nogroup --column --color "%s"', | |
\ escape(empty(<q-args>) ? '^(?=.)' : <q-args>, '"\')), | |
\ 'sink*': function('<sid>ag_handler'), | |
\ 'options': '--ansi --expect=ctrl-t,ctrl-v,ctrl-x --delimiter : --nth 4.. '. | |
\ '--multi --bind ctrl-a:select-all,ctrl-d:deselect-all '. | |
\ '--color hl:68,hl+:110', | |
\ 'down': '50%' | |
\ }) | |
" ---------------------------------------------------------------------------- | |
" Experimental | |
" ---------------------------------------------------------------------------- | |
command! -bang AutoSave | |
\ augroup autosave | |
\| exec 'autocmd!' | |
\| if <bang>1 | |
\| exec 'autocmd TextChanged,InsertLeave <buffer> silent update' | |
\| endif | |
\| augroup END | |
function! Consolate() | |
:execute "normal! Oconsole.log();\<esc>hP" | |
endfunction | |
command! -nargs=0 Consolate :call Consolate() | |
function! EditSubstitute(args) | |
if (len(a:args))<2 | |
return | |
endif | |
let s:delimiter = (a:args[0]) | |
let s:split = split(a:args,s:delimiter,1)[1:] | |
let s:fullpath = expand('%:p') | |
let s:bar = substitute(s:fullpath, s:split[0], s:split[1], '') | |
echo (s:bar) | |
silent execute('edit '.s:bar) | |
endfunction | |
command! -nargs=* EditSubstitute :call EditSubstitute(<q-args>) | |
command! -nargs=* Et :call EditSubstitute("/src\\(.*\\)\\.js/test\\1.test.js") | |
command! -nargs=* Es :call EditSubstitute("/test\\(.*\\)\\.test.js/src\\1.js") | |
" ------------------- | |
" Windowing repeating | |
" ------------------- | |
function! s:Wincmd(count, key) | |
" If count is not zero, use the original count. If otherwise, don't | |
" include a count. | |
let if_count = a:count ? a:count : '' | |
" This builds a wincmd from the given key, and saves it so | |
" it can be repeated. | |
let g:last_wincmd = 'wincmd ' . nr2char(a:key) | |
" Execute the built wincmd | |
execute if_count . g:last_wincmd | |
endfunction | |
function! s:WincmdRepeat(count) | |
" If a count is given, repeat the last wincmd that amount of times. | |
" If otherwise, just repeat once. | |
let if_count = a:count ? a:count : '' | |
execute if_count . g:last_wincmd | |
endfunction | |
" Overwrite the default <C-w> mapping so that the last wincmd can be kept | |
" track of. The getchar function is what captures the key pressed | |
" directly afterwards. The <C-u> is to remove any cmdline range that vim | |
" automatically inserted. | |
nnoremap <silent> <C-w> :<C-u>call <SID>Wincmd(v:count, getchar())<cr> | |
" This just calls the function which repeats the previous wincmd. It | |
" does except a count, which is the number of times it should repeat the | |
" previous wincmd. Also, you can replace Q with whatever key you want. | |
nnoremap <silent> Q :<C-u> call <SID>WincmdRepeat(v:count)<cr> | |
" ---------------------------------------------------------------------------- | |
" Filetype defaults | |
" ---------------------------------------------------------------------------- | |
augroup Filetypes | |
autocmd! | |
autocmd BufEnter *.vimrc :setlocal foldmethod=expr foldexpr=VimrcFolds() foldtext=VimrcFoldText() | |
autocmd BufEnter *.md,*.markdown :setlocal filetype=markdown | |
autocmd BufEnter *.coffee :setlocal filetype=coffee | |
autocmd BufEnter *.yml,*.yaml :setlocal filetype=yaml | |
autocmd BufEnter *.exl :setlocal filetype=exl | |
autocmd BufEnter *.bowerrc,*.babelrc,*.eslintrc :setlocal filetype=json | |
autocmd BufEnter *.es6 :setlocal filetype=javascript | |
autocmd BufNewFile,BufReadPost,BufFilePost *.js,*.bowerrc,*.babelrc,*.eslintrc,*.yml,*.yaml,*.es6 :setlocal tabstop=2 shiftwidth=2 softtabstop=2 expandtab | |
autocmd FileType php nnoremap <Leader>p :call pdv#DocumentWithSnip()<cr> | |
autocmd FileType php vnoremap <Leader>p :call pdv#DocumentWithSnip()<cr> | |
autocmd FileType xml setlocal equalprg=export\ XMLLINT_INDENT\=\"\ \ \ \ \"\ &&\ xmllint\ --format\ --recover\ -\ 2>/dev/null | |
autocmd FileType netrw setl bufhidden=wipe | |
autocmd FileType markdown,bash,sh,html,coffee :setlocal noexpandtab | |
autocmd FileType markdown :setlocal listchars=tab:\ \ ,trail:- | |
autocmd FileType yaml,vim,coffee,html,sql,json,phtml,php,js,javascript,txt,md,python,css,rb,md,markdown,bash,sh,shell autocmd BufWritePre <buffer> :call StripTrailingWhitespace() | |
autocmd BufWritePost * :silent !touch /tmp/swatch | |
augroup END | |
" ----------- | |
" FZF | |
" ----------- | |
function! s:buflist() | |
redir => ls | |
silent ls | |
redir END | |
return split(ls, '\n') | |
endfunction | |
function! s:bufopen(e) | |
execute 'buffer' matchstr(a:e, '^[ 0-9]*') | |
endfunction | |
command! VerticalTerm :vs term://zsh | |
nnoremap <silent> <A-n> :VerticalTerm<cr>A | |
nnoremap <silent> <Leader>C :call fzf#run({ | |
\ 'source': | |
\ map(split(globpath(&rtp, "colors/*.vim"), "\n"), | |
\ "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"), | |
\ 'sink': 'colo', | |
\ 'options': '+m', | |
\ 'left': 20, | |
\ 'launcher': 'xterm -geometry 20x30 -e bash -ic %s' | |
\ })<cr> | |
nnoremap <silent> <C-b> :call fzf#run({ | |
\ 'source': reverse(<sid>buflist()), | |
\ 'sink': function('<sid>bufopen'), | |
\ 'options': '+m', | |
\ 'down': len(<sid>buflist()) + 2 | |
\ })<cr> | |
nnoremap Y y$ | |
nnoremap <C-p> :call fzf#run({ | |
\ 'dir':expand('%:p:h'), | |
\ 'sink': 'e' | |
\ })<cr> | |
nnoremap <silent> <C-f> :FZF<cr> | |
command! FZFTag if !empty(tagfiles()) | call fzf#run({ | |
\ 'source': "sed '/^\\!/d;s/\t.*//' " . join(tagfiles()) . ' | nauniq', | |
\ 'sink': 'tag', | |
\ 'options': '+m', | |
\ 'left': 60, | |
\ }) | else | echo 'No tags' | endif | |
nnoremap <silent> <Leader>t :FZFTag<cr> | |
" ============================================================================ | |
" V - v:oldfiles | |
" ============================================================================ | |
command! V | |
\ call fzf#run({'source': filter(copy(v:oldfiles), '!empty(glob(v:val))'), | |
\ 'sink': 'e', | |
\ 'down': '30%'}) | |
" ==================== | |
" Buffer search | |
" ==================== | |
function! s:line_handler(l) | |
let keys = split(a:l, ':\t') | |
exec 'buf' keys[0] | |
exec keys[1] | |
normal! ^zz | |
endfunction | |
function! s:buffer_lines() | |
let res = [] | |
for b in filter(range(1, bufnr('$')), 'buflisted(v:val)') | |
call extend(res, map(getbufline(b,0,'$'), 'b . ":\t" . (v:key + 1) . ":\t" . v:val ')) | |
endfor | |
return res | |
endfunction | |
command! FZFLines call fzf#run({ | |
\ 'source': <sid>buffer_lines(), | |
\ 'sink': function('<sid>line_handler'), | |
\ 'options': '--extended --nth=3..', | |
\ 'down': '60%' | |
\}) | |
function! s:align_lists(lists) | |
let maxes = {} | |
for list in a:lists | |
let i = 0 | |
while i < len(list) | |
let maxes[i] = max([get(maxes, i, 0), len(list[i])]) | |
let i += 1 | |
endwhile | |
endfor | |
for list in a:lists | |
call map(list, "printf('%-'.maxes[v:key].'s', v:val)") | |
endfor | |
return a:lists | |
endfunction | |
function! s:btags_source() | |
let lines = map(split(system(printf( | |
\ 'ctags -f - --sort=no --excmd=number --language-force=%s %s', | |
\ &filetype, expand('%:S'))), "\n"), 'split(v:val, "\t")') | |
if v:shell_error | |
throw 'failed to extract tags' | |
endif | |
return map(s:align_lists(lines), 'join(v:val, "\t")') | |
endfunction | |
function! s:btags_sink(line) | |
execute split(a:line, "\t")[2] | |
endfunction | |
function! s:btags() | |
try | |
call fzf#run({'source': s:btags_source(), | |
\'down': '40%', | |
\'options': '+m -d "\t" --with-nth 1,4.. -n 1 --tiebreak=index', | |
\'sink': function('s:btags_sink')}) | |
catch | |
echohl WarningMsg | |
echom v:exception | |
echohl None | |
endtry | |
endfunction | |
command! BTags call s:btags() | |
" ------------- | |
" Cleanup commands | |
" ------------- | |
func! AddSpaceAfterColumn() | |
s/:\([\$(_a-z0-9\[\]"']\)/: \1/ge | |
endfunc | |
func! AddSpaceBeforeEqual() | |
s/\([a-z)_0-9"'\[\]]\)=/\1 =/ge | |
endfunc | |
func! AddSpaceAfterEqual() | |
s/=\([\$(_a-z0-9\[\]"']\)/= \1/ge | |
endfunc | |
func! AddSpaceAfterArrow() | |
s/=>\([\$a-z0-9"'\[\]]\)/=> \1/ge | |
endfunc | |
func! AddSpaceAfterComma() | |
s/,\(\S\)/, \1/ge | |
endfunc | |
func! CleanUpFileHabiteo() | |
% call AddSpaceAfterComma() | |
% call AddSpaceBeforeEqual() | |
% call AddSpaceAfterEqual() | |
% call AddSpaceAfterArrow() | |
endfunc | |
func! CleanUpLineHabiteo() | |
call AddSpaceAfterComma() | |
call AddSpaceBeforeEqual() | |
call AddSpaceAfterEqual() | |
call AddSpaceAfterArrow() | |
endfunc | |
function! QueryAlign() | |
let _s=@/ | |
:norm ma | |
:norm V}k | |
:norm ^10<" | |
:silent '<,'>norm I + " | |
:silent '<,'>norm A" | |
:norm `a | |
let @/=_s | |
endfunction | |
function! TableAlign() | |
let _s=@/ | |
:norm ma | |
/| | |
:norm V} | |
:Align | | |
:silent norm 2< | |
execute "normal! \<Esc>" | |
:norm `a | |
let @/=_s | |
endfunction | |
function! StripTrailingWhitespace() | |
let l:winview = winsaveview() | |
silent! %s/\s\+$// | |
call winrestview(l:winview) | |
endfunction | |
" ---------------------------------------------------------------------------- | |
" Filetype specific settings | |
" ---------------------------------------------------------------------------- | |
function! VimrcFolds() | |
let thisline = getline(v:lnum) | |
let next2line = getline(v:lnum+2) | |
if match(thisline, '^" ----') >=0 && match(next2line, '^" ----') >= 0 | |
return '>1' | |
else | |
return '=' | |
endif | |
endfunction | |
function! VimrcFoldText() | |
let foldsize = (v:foldend-v:foldstart) | |
return getline(v:foldstart+1).' ('.foldsize.' lines)' | |
endfunction | |
function! s:GoyoEnter() | |
:silent !tmux set status off | |
:set noshowmode | |
:set nonumber | |
:setlocal wrap | |
:setlocal wrapmargin=80 | |
let b:quitting = 0 | |
let b:quitting_bang = 0 | |
autocmd QuitPre <buffer> let b:quitting = 1 | |
cabbrev <buffer> q! let b:quitting_bang = 1 <bar> q! | |
endfunction | |
function! s:GoyoLeave() | |
:silent !tmux set status on | |
" Quit Vim if this is the only remaining buffer | |
if b:quitting && len(filter(range(1, bufnr('$')), 'buflisted(v:val)')) == 1 | |
if b:quitting_bang | |
qa! | |
else | |
qa | |
endif | |
endif | |
:set showmode | |
:setlocal number | |
:setlocal nowrap | |
endfunction | |
augroup Goyo | |
autocmd! | |
autocmd User GoyoEnter nested call <SID>GoyoEnter() | |
autocmd User GoyoLeave nested call <SID>GoyoLeave() | |
augroup END | |
" --------- | |
" GVIM specific | |
" --------- | |
let s:pattern = '^\(.* \)\([1-9][0-9]*\)$' | |
let s:minfontsize = 6 | |
let s:maxfontsize = 16 | |
function! AdjustFontSize(amount) | |
if has('gui_gtk2') && has('gui_running') | |
let fontname = substitute(&guifont, s:pattern, '\1', '') | |
let cursize = substitute(&guifont, s:pattern, '\2', '') | |
let newsize = cursize + a:amount | |
if (newsize >= s:minfontsize) && (newsize <= s:maxfontsize) | |
let newfont = fontname . newsize | |
let &guifont = newfont | |
endif | |
else | |
echoerr 'You need to run the GTK2 version of Vim to use this function.' | |
endif | |
endfunction | |
function! LargerFont() | |
call AdjustFontSize(1) | |
endfunction | |
command! LargerFont call LargerFont() | |
function! SmallerFont() | |
call AdjustFontSize(-1) | |
endfunction | |
command! SmallerFont call SmallerFont() | |
" ---------- | |
" Motion mappings | |
" ---------- | |
function! s:Buflisted() | |
return filter(range(1, bufnr('$')), 'buflisted(v:val)') | |
endfunction | |
function! g:Go_to_last_file() | |
let b = extend( | |
\ filter(copy(v:oldfiles), | |
\ "v:val !~? 'fugitive:\\|^/tmp/\\|.git/'"), | |
\ filter(map(s:Buflisted(), 'bufname(v:val)'), '!empty(v:val)')) | |
execute('e ' . b[0]) | |
return b[0] | |
endfunction | |
command! L silent call g:Go_to_last_file() | |
function! s:ZealMotion(type) abort | |
let reg_save = @@ | |
call s:CopyMotionForType(a:type) | |
execute "normal :!tmux split \"source ~/scripts/zeal.load ; zealdoc '" . shellescape(@@) ."'\" \<cr>" | |
let @@ = reg_save | |
endfunction | |
function! s:SearchMotion(type) abort | |
let reg_save = @@ | |
call s:CopyMotionForType(a:type) | |
execute 'normal! :!firefox -search ' . shellescape(@@) . "\<cr>" | |
let @@ = reg_save | |
endfunction | |
function! s:NpmInstallMotion(type) abort | |
let reg_save = @@ | |
call s:CopyMotionForType(a:type) | |
execute 'normal! :!npm install --save ' . shellescape(@@) . "\<cr>" | |
let @@ = reg_save | |
endfunction | |
function! s:CopyMotionForType(type) | |
if a:type ==# 'v' | |
silent execute 'normal! `<' . a:type . '`>y' | |
elseif a:type ==# 'char' | |
silent execute 'normal! `[v`]y' | |
endif | |
endfunction | |
function! s:AMotion(type) abort | |
let reg_save = @@ | |
call s:CopyMotionForType(a:type) | |
execute 'normal! :A ' . @@ . "\<cr>" | |
let @@ = reg_save | |
endfunction | |
nnoremap <silent> <Leader>a :set opfunc=<SID>AMotion<cr>g@ | |
xnoremap <silent> <Leader>a :<C-U>call <SID>AMotion(visualmode())<cr> | |
function! s:AgMotion(type) abort | |
let reg_save = @@ | |
call s:CopyMotionForType(a:type) | |
execute 'normal! :Ag ' . shellescape(@@) . "\<cr>" | |
let @@ = reg_save | |
endfunction | |
nnoremap <silent> <Leader>z :set opfunc=<SID>ZealMotion<cr>g@ | |
xnoremap <silent> <Leader>z :<C-U>call <SID>ZealMotion(visualmode())<cr> | |
nnoremap <silent> <Leader>f :set opfunc=<SID>SearchMotion<cr>g@ | |
xnoremap <silent> <Leader>f :<C-U>call <SID>SearchMotion(visualmode())<cr> | |
nnoremap <silent> <Leader>n :set opfunc=<SID>NpmInstallMotion<cr>g@ | |
xnoremap <silent> <Leader>n :<C-U>call <SID>NpmInstallMotion(visualmode())<cr> | |
" ---------- | |
" Normal mappings | |
" ---------- | |
" maximize current visible window | |
nnoremap <Leader>o :only<cr> | |
nnoremap <Leader>d :e %:h<cr> | |
nnoremap <up> :m .-2<cr>== | |
nnoremap <down> :m .+1<cr>== | |
inoremap <up> <Esc>:m .-2<cr>==gi | |
inoremap <down> <Esc>:m .+1<cr>==gi | |
nnoremap <right> :bn<cr> | |
nnoremap <left> :bp<cr> | |
vnoremap <down> :m '>+1<cr>gv | |
vnoremap <up> :m '<-2<cr>gv | |
nnoremap <A-4> :tabprevious<cr> | |
nnoremap <A-6> :tabnext<cr> | |
nnoremap <A-5> :tabnew<cr> | |
inoremap jj <Esc> | |
nnoremap <Leader>ev :e ~/.${VIM_V}rc<cr> | |
nnoremap <Leader>eb :e ~/.bashrc<cr> | |
nnoremap <Leader>eu :e ~/.config/nvim/plugged<cr> | |
nnoremap <Leader>et :e ~/.tmux.conf<cr> | |
"Source vimrc | |
nnoremap <Leader>sv :source $MYVIMRC<cr> | |
"remove find results | |
command! H let @/='' | |
nnoremap <silent><esc> <esc>:nohlsearch<CR><esc> | |
nnoremap <space> : | |
nnoremap <C-n> :bp\|bd #<cr> | |
nnoremap <ScrollWhellUp> <C-Y> | |
nnoremap <ScrollWhellDown> <C-E> | |
highlight SignColumn ctermbg=brown | |
highlight SignColumn ctermfg=white | |
nnoremap <Leader>l :FZFLines<cr> | |
function! LocationPrevious() | |
try | |
lprev | |
catch /^Vim\%((\a\+)\)\=:E553/ | |
echom('ep') | |
llast | |
catch /^Vim\%((\a\+)\)\=:E776/ | |
echom('No location list') | |
catch /^Vim\%((\a\+)\)\=:E42/ | |
echom('No Errors') | |
endtry | |
endfunction | |
function! LocationNext() | |
try | |
lnext | |
catch /^Vim\%((\a\+)\)\=:E553/ | |
lfirst | |
catch /^Vim\%((\a\+)\)\=:E776/ | |
echom('No location list') | |
catch /^Vim\%((\a\+)\)\=:E42/ | |
echom('No Errors') | |
endtry | |
endfunction | |
inoremap <F1> <nop> | |
nnoremap <F1> :call LocationNext()<cr> | |
nnoremap <F2> :call LocationPrevious()<cr> | |
nnoremap <Leader>c :read !cat<cr> | |
nnoremap K :Neomake<cr> | |
nnoremap \k :w! \| :Neomake<cr> | |
if(has("nvim")) | |
tnoremap <Esc> <C-\><C-n> | |
tnoremap <A-h> <C-\><C-n><C-w>h | |
tnoremap <A-j> <C-\><C-n><C-w>j | |
tnoremap <A-k> <C-\><C-n><C-w>k | |
tnoremap <A-l> <C-\><C-n><C-w>l | |
tnoremap <a-a> <esc>a | |
tnoremap <a-b> <esc>b | |
tnoremap <a-d> <esc>d | |
tnoremap <a-f> <esc>f | |
endif | |
nnoremap <A-h> <C-w>h | |
nnoremap <A-j> <C-w>j | |
nnoremap <A-k> <C-w>k | |
nnoremap <A-l> <C-w>l | |
cnoremap <Esc>b <S-Left> | |
cnoremap <Esc>f <S-Right> | |
cnoremap <A-b> <S-Left> | |
cnoremap <A-f> <S-Right> | |
cnoremap <A-d> <S-Right><C-w> | |
nnoremap <silent> <Leader>v :BTags<cr> | |
nnoremap \\ :w!<cr> | |
function! EslintFix() | |
:w! | |
:!jlint % --fix | |
:e | |
endfunction | |
nnoremap \s :call EslintFix()<cr> | |
nnoremap <Leader>q :qa!<cr> | |
" Save a file as root (,W) | |
nnoremap <leader>W :w !sudo tee % > /dev/null<cr> | |
function! s:ToggleTestOnly() | |
let l:winview = winsaveview() | |
if match(join(getline(1,'.'), "\n"),"describe\\\.only")!=-1 || match(join(getline(1,'.'), "\n"),"it\\\.only")!=-1 | |
normal j | |
silent execute "?only(" | |
normal 0f.dt( | |
else | |
let l:itmatch=match(join(reverse(getline(1,'.')), '\n'),'it(') | |
let l:dematch=match(join(reverse(getline(1,'.')), '\n'),'describe(') | |
if (l:itmatch==-1 && l:dematch==-1) | |
return | |
endif | |
normal j | |
if l:itmatch<l:dematch && l:itmatch!=-1 | |
silent execute "?it(" | |
else | |
silent execute "?describe(" | |
endif | |
normal ea.only | |
endif | |
call winrestview(l:winview) | |
endfunction | |
command! ToggleTestOnly call s:ToggleTestOnly() | |
nnoremap <Leader>n :ToggleTestOnly<cr> | |
" Toggle the UndoTree on an off with F8 | |
nnoremap <F8> :UndotreeToggle<cr> | |
function! CopyWholeFile() | |
let l:winview = winsaveview() | |
let _s=@/ | |
:norm ggyG | |
:call CopyVar() | |
let @/=_s | |
call winrestview(l:winview) | |
endfunction | |
function! CopyVar() | |
redir! > /tmp/varfile | sil exe 'echo @"' |redir end | |
call system ("sed '1d' /tmp/varfile > /tmp/tmpvarfile; mv /tmp/tmpvarfile /tmp/varfile") | |
call system('cat /tmp/varfile | copy && rm /tmp/varfile') | |
endfunction | |
nnoremap <Leader>y :call CopyVar()<cr> | |
nnoremap <Leader>Y :call CopyWholeFile()<cr> | |
nnoremap gn :GitGutterNextHunk<cr> | |
nnoremap gN :GitGutterPrevHunk<cr> | |
nnoremap gs :GitGutterStageHunk<cr> | |
nnoremap gr :GitGutterRevertHunk<cr> | |
"====[ I'm sick of typing :%s/.../.../g ]======= | |
nnoremap S :%s//g<LEFT><LEFT> | |
nnoremap <expr> M ':%s/' . @/ . '//g<LEFT><LEFT>' | |
vnoremap <expr> M ':s/' . @/ . '//g<LEFT><LEFT>' | |
" Because , is useful but is our leader | |
nnoremap ,, , | |
" Open last selected area when pasted | |
noremap gV `[v`] | |
nnoremap yr :.w !bash<cr> | |
vnoremap < <gv | |
vnoremap > >gv | |
cnoremap :: <C-r>=expand('%:p:h').'/'<cr> | |
function! s:escaped(first, last) abort | |
let files = getline(a:first, a:last) | |
call filter(files, 'v:val !~# "^\" "') | |
call map(files, 'substitute(v:val, "[/*|@=]\\=\\%(\\t.*\\)\\=$", "", "")') | |
return join(map(files, 'fnamemodify(b:netrw_curdir."/".v:val,":~:.")'), ' ') | |
endfunction | |
cnoremap ;; <C-R>=<SID>escaped(line('.'), line('.') - 1 + v:count1)<cr> | |
" Make vaa select the entire file... | |
vmap aa VGo1G | |
imap <c-x><c-k> <plug>(fzf-complete-word) | |
imap <c-x><c-f> <plug>(fzf-complete-file-ag) | |
imap <c-x><c-j> <plug>(fzf-complete-file-ag) | |
imap <c-x><c-l> <plug>(fzf-complete-line) | |
" fzf mappings | |
nnoremap <Leader>m :Map<cr> | |
" fzf buffers | |
nnoremap <Leader>b :Buffers<cr> | |
" Align | Tables | |
nnoremap <Leader>g :call TableAlign()<cr> | |
" Search with */# from visual mode | |
vnoremap * "zy/<c-r>z<cr> | |
vnoremap # "zy?<c-r>z<cr>n | |
nnoremap <silent> <Leader>ag :Ag <C-R><C-W><cr> | |
silent !echo $NVIM_LISTEN_ADDRESS >> /tmp/nvim_listen_adress | |
function! Eslint() | |
call system('cat .gitignore .eslintignore > /tmp/ignore_path; jlint . --ignore-path /tmp/ignore_path --fix --cache -f unix | grep "^$" -v | grep -v -E "[0-9]+ problems?" > /tmp/qf') | |
cfile /tmp/qf | |
copen | |
endfunction | |
nnoremap <Leader>p :call Eslint()<cr> | |
function! RealignColumns() | |
%s/:\([{"]\)/: \1/g | |
endfunction | |
" Open tag in new vsplit | |
nnoremap <silent><Leader><C-]> <C-w><C-]><C-w>L | |
fun! UltiVim() | |
exec 'e ~/.vim/UltiSnips/'. &filetype . '.snippets' | |
endf | |
command! UltiVim :call UltiVim() | |
fun! s:DetectSheBang() | |
if getline(1) ==# '#!/bin/bash' | |
set ft=sh | |
endif | |
endfun | |
fun! s:OpenTermAsync() | |
let command = 'echo "foo" > /tmp/f' | |
silent exec 'enew' | |
call termopen(command,) | |
silent exec 'stopinsert' | |
bp | |
endfun | |
command! Ta :call s:OpenTermAsync() | |
augroup detectShebang | |
autocmd! | |
autocmd BufNewFile,BufRead * call s:DetectSheBang() | |
augroup END | |
"I have the habit of recording scratch macros in the q register. This makes playback easier. | |
nnoremap <bs> @q | |
"With this I don't have to do stuff like 100@q, I can just visually select lines and press backspace. | |
vnoremap <silent> <bs> :norm @q<cr> | |
" :let @q = '^'<cr> stores ^ inside register q | |
" ^ moves the cursor to the first non whitespace character on the line | |
" qQ begins recording a macro inside register q by appending (!=overwriting) the next typed keys to its previous content (qq would overwrite the ^ we just stored in @q) | |
nnoremap qq :let @q = '^'<cr>^qQ | |
nnoremap \ <C-w> | |
nnoremap ,A :A<cr> | |
nnoremap s ciw | |
nnoremap <F8> :TagbarToggle<cr> | |
nnoremap <C-w>f :vertical wincmd f<cr> | |
nnoremap <leader>m :<c-u><c-r>='let @'. 'q' .' = '. string(getreg("q"))<cr><c-f><left> | |
" Profile | |
" ---------------------------------------------------------------------------- | |
function! s:profile(bang) | |
if a:bang | |
profile pause | |
noautocmd qall | |
else | |
profile start /tmp/profile.log | |
profile func * | |
profile file * | |
endif | |
endfunction | |
command! -bang Profile call s:profile(<bang>0) | |
command! -nargs=* Viw execute('e '.system(printf('getloc "%s"',escape(empty(<q-args>) ? '' : <q-args>, '"\')))) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment