Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: c35e33cb9c
Fetching contributors…

Cannot retrieve contributors at this time

755 lines (603 sloc) 26.081 kb
"
" Personal preference .vimrc file
" Maintained by Vincent Driessen <vincent@datafox.nl>
"
" My personally preferred version of vim is the one with the "big" feature
" set, in addition to the following configure options:
"
" ./configure --with-features=BIG
" --enable-pythoninterp --enable-rubyinterp
" --enable-enablemultibyte --enable-gui=no --with-x --enable-cscope
" --with-compiledby="Vincent Driessen <vincent@datafox.nl>"
" --prefix=/usr
"
" To start vim without using this .vimrc file, use:
" vim -u NORC
"
" To start vim without loading any .vimrc or plugins, use:
" vim -u NONE
"
" Use vim settings, rather then vi settings (much better!)
" This must be first, because it changes other options as a side effect.
set nocompatible
" Use pathogen to easily modify the runtime path to include all plugins under
" the ~/.vim/bundle directory
filetype off " force reloading *after* pathogen loaded
call pathogen#infect()
call pathogen#helptags()
filetype plugin indent on " enable detection, plugins and indenting in one step
syntax on
" Change the mapleader from \ to ,
let mapleader=","
let maplocalleader="\\"
" Editing behaviour {{{
set showmode " always show what mode we're currently editing in
set nowrap " don't wrap lines
set tabstop=4 " a tab is four spaces
set softtabstop=4 " when hitting <BS>, pretend like a tab is removed, even if spaces
set expandtab " expand tabs by default (overloadable per file type later)
set shiftwidth=4 " number of spaces to use for autoindenting
set shiftround " use multiple of shiftwidth when indenting with '<' and '>'
set backspace=indent,eol,start " allow backspacing over everything in insert mode
set autoindent " always set autoindenting on
set copyindent " copy the previous indentation on autoindenting
set number " always show line numbers
set showmatch " set show matching parenthesis
set ignorecase " ignore case when searching
set smartcase " ignore case if search pattern is all lowercase,
" case-sensitive otherwise
set smarttab " insert tabs on the start of a line according to
" shiftwidth, not tabstop
set scrolloff=4 " keep 4 lines off the edges of the screen when scrolling
set virtualedit=all " allow the cursor to go in to "invalid" places
set hlsearch " highlight search terms
set incsearch " show search matches as you type
set gdefault " search/replace "globally" (on a line) by default
set listchars=tab:\ ,trail:·,extends:#,nbsp:·
set nolist " don't show invisible characters by default,
" but it is enabled for some file types (see later)
set pastetoggle=<F2> " when in insert mode, press <F2> to go to
" paste mode, where you can paste mass data
" that won't be autoindented
set mouse=a " enable using the mouse if terminal emulator
" supports it (xterm does)
set fileformats="unix,dos,mac"
set formatoptions+=1 " When wrapping paragraphs, don't end lines
" with 1-letter words (looks stupid)
set nrformats= " make <C-a> and <C-x> play well with
" zero-padded numbers (i.e. don't consider
" them octal or hex)
" Toggle show/hide invisible chars
nnoremap <leader>i :set list!<cr>
" Toggle line numbers
nnoremap <leader>N :setlocal number!<cr>
" Thanks to Steve Losh for this liberating tip
" See http://stevelosh.com/blog/2010/09/coming-home-to-vim
nnoremap / /\v
vnoremap / /\v
" Speed up scrolling of the viewport slightly
nnoremap <C-e> 2<C-e>
nnoremap <C-y> 2<C-y>
" }}}
" Folding rules {{{
set foldenable " enable folding
set foldcolumn=2 " add a fold column
set foldmethod=marker " detect triple-{ style fold markers
set foldlevelstart=99 " start out with everything folded
set foldopen=block,hor,insert,jump,mark,percent,quickfix,search,tag,undo
" which commands trigger auto-unfold
function! MyFoldText()
let line = getline(v:foldstart)
let nucolwidth = &fdc + &number * &numberwidth
let windowwidth = winwidth(0) - nucolwidth - 3
let foldedlinecount = v:foldend - v:foldstart
" expand tabs into spaces
let onetab = strpart(' ', 0, &tabstop)
let line = substitute(line, '\t', onetab, 'g')
let line = strpart(line, 0, windowwidth - 2 -len(foldedlinecount))
let fillcharcount = windowwidth - len(line) - len(foldedlinecount) - 4
return line . ' …' . repeat(" ",fillcharcount) . foldedlinecount . ' '
endfunction
set foldtext=MyFoldText()
" }}}
" Editor layout {{{
set termencoding=utf-8
set encoding=utf-8
set lazyredraw " don't update the display while executing macros
set laststatus=2 " tell VIM to always put a status line in, even
" if there is only one window
set cmdheight=2 " use a status bar that is 2 rows high
" }}}
" Vim behaviour {{{
set hidden " hide buffers instead of closing them this
" means that the current buffer can be put
" to background without being written; and
" that marks and undo history are preserved
set switchbuf=useopen " reveal already opened files from the
" quickfix window instead of opening new
" buffers
set history=1000 " remember more commands and search history
set undolevels=1000 " use many muchos levels of undo
if v:version >= 730
set undofile " keep a persistent backup file
set undodir=~/.vim/.undo,~/tmp,/tmp
endif
set nobackup " do not keep backup files, it's 70's style cluttering
set noswapfile " do not write annoying intermediate swap files,
" who did ever restore from swap files anyway?
set directory=~/.vim/.tmp,~/tmp,/tmp
" store swap files in one of these directories
" (in case swapfile is ever turned on)
set viminfo='20,\"80 " read/write a .viminfo file, don't store more
" than 80 lines of registers
set wildmenu " make tab completion for files/buffers act like bash
set wildmode=list:full " show a list when pressing tab and complete
" first full match
set wildignore=*.swp,*.bak,*.pyc,*.class
set title " change the terminal's title
set visualbell " don't beep
set noerrorbells " don't beep
set showcmd " show (partial) command in the last line of the screen
" this also shows visual selection info
set nomodeline " disable mode lines (security measure)
"set ttyfast " always use a fast terminal
set cursorline " underline the current line, for quick orientation
" }}}
" Toggle the quickfix window {{{
" From Steve Losh, http://learnvimscriptthehardway.stevelosh.com/chapters/38.html
nnoremap <C-q> :call <SID>QuickfixToggle()<cr>
let g:quickfix_is_open = 0
function! s:QuickfixToggle()
if g:quickfix_is_open
cclose
let g:quickfix_is_open = 0
execute g:quickfix_return_to_window . "wincmd w"
else
let g:quickfix_return_to_window = winnr()
copen
let g:quickfix_is_open = 1
endif
endfunction
" }}}
" Toggle the foldcolumn {{{
nnoremap <leader>f :call FoldColumnToggle()<cr>
let g:last_fold_column_width = 4 " Pick a sane default for the foldcolumn
function! FoldColumnToggle()
if &foldcolumn
let g:last_fold_column_width = &foldcolumn
setlocal foldcolumn=0
else
let &l:foldcolumn = g:last_fold_column_width
endif
endfunction
" }}}
" Highlighting {{{
if &t_Co > 2 || has("gui_running")
syntax on " switch syntax highlighting on, when the terminal has colors
endif
" }}}
" Shortcut mappings {{{
" Since I never use the ; key anyway, this is a real optimization for almost
" all Vim commands, as I don't have to press the Shift key to form chords to
" enter ex mode.
nnoremap ; :
nnoremap <leader>; ;
" Avoid accidental hits of <F1> while aiming for <Esc>
noremap! <F1> <Esc>
" Quickly close the current window
nnoremap <leader>q :q<CR>
" Use Q for formatting the current paragraph (or visual selection)
vnoremap Q gq
nnoremap Q gqap
" make p in Visual mode replace the selected text with the yank register
vnoremap p <Esc>:let current_reg = @"<CR>gvdi<C-R>=current_reg<CR><Esc>
" Shortcut to make
nnoremap mk :make<CR>
" Swap implementations of ` and ' jump to markers
" By default, ' jumps to the marked line, ` jumps to the marked line and
" column, so swap them
nnoremap ' `
nnoremap ` '
" Use the damn hjkl keys
" noremap <up> <nop>
" noremap <down> <nop>
" noremap <left> <nop>
" noremap <right> <nop>
" Remap j and k to act as expected when used on long, wrapped, lines
nnoremap j gj
nnoremap k gk
" Easy window navigation
noremap <C-h> <C-w>h
noremap <C-j> <C-w>j
noremap <C-k> <C-w>k
noremap <C-l> <C-w>l
nnoremap <leader>w <C-w>v<C-w>l
" Complete whole filenames/lines with a quicker shortcut key in insert mode
inoremap <C-f> <C-x><C-f>
inoremap <C-l> <C-x><C-l>
" Use ,d (or ,dd or ,dj or 20,dd) to delete a line without adding it to the
" yanked stack (also, in visual mode)
nnoremap <silent> <leader>d "_d
vnoremap <silent> <leader>d "_d
" Quick yanking to the end of the line
nnoremap Y y$
" Yank/paste to the OS clipboard with ,y and ,p
nnoremap <leader>y "+y
nnoremap <leader>Y "+yy
nnoremap <leader>p "+p
nnoremap <leader>P "+P
" YankRing stuff
let g:yankring_history_dir = '$HOME/.vim/.tmp'
nnoremap <leader>r :YRShow<CR>
" Edit the vimrc file
nnoremap <silent> <leader>ev :e $MYVIMRC<CR>
nnoremap <silent> <leader>sv :so $MYVIMRC<CR>
" Clears the search register
nnoremap <silent> <leader>/ :nohlsearch<CR>
" Pull word under cursor into LHS of a substitute (for quick search and
" replace)
nnoremap <leader>z :%s#\<<C-r>=expand("<cword>")<CR>\>#
" Keep search matches in the middle of the window and pulse the line when moving
" to them.
nnoremap n n:call PulseCursorLine()<cr>
nnoremap N N:call PulseCursorLine()<cr>
" Quickly get out of insert mode without your fingers having to leave the
" home row (either use 'jj' or 'jk')
inoremap jj <Esc>
" Quick alignment of text
nnoremap <leader>al :left<CR>
nnoremap <leader>ar :right<CR>
nnoremap <leader>ac :center<CR>
" Sudo to write
cnoremap w!! w !sudo tee % >/dev/null
" Jump to matching pairs easily, with Tab
nnoremap <Tab> %
vnoremap <Tab> %
" Folding
nnoremap <Space> za
vnoremap <Space> za
" Strip all trailing whitespace from a file, using ,w
nnoremap <leader>W :%s/\s\+$//<CR>:let @/=''<CR>
" Ack for the word under cursor
"nnoremap <leader>a :Ack<Space>
nnoremap <leader>a :Ack<Space><c-r><c-W>
" Creating folds for tags in HTML
"nnoremap <leader>ft Vatzf
" Reselect text that was just pasted with ,v
nnoremap <leader>v V`]
" Gundo.vim
nnoremap <F5> :GundoToggle<CR>
" }}}
" NERDTree settings {{{
" Put focus to the NERD Tree with F3 (tricked by quickly closing it and
" immediately showing it again, since there is no :NERDTreeFocus command)
nnoremap <leader>n :NERDTreeClose<CR>:NERDTreeToggle<CR>
nnoremap <leader>m :NERDTreeClose<CR>:NERDTreeFind<CR>
nnoremap <leader>N :NERDTreeClose<CR>
" Store the bookmarks file
let NERDTreeBookmarksFile=expand("$HOME/.vim/NERDTreeBookmarks")
" Show the bookmarks table on startup
let NERDTreeShowBookmarks=1
" Show hidden files, too
let NERDTreeShowFiles=1
let NERDTreeShowHidden=1
" Quit on opening files from the tree
let NERDTreeQuitOnOpen=1
" Highlight the selected entry in the tree
let NERDTreeHighlightCursorline=1
" Use a single click to fold/unfold directories and a double click to open
" files
let NERDTreeMouseMode=2
" Don't display these kinds of files
let NERDTreeIgnore=[ '\.pyc$', '\.pyo$', '\.py\$class$', '\.obj$',
\ '\.o$', '\.so$', '\.egg$', '^\.git$' ]
" }}}
" TagList settings {{{
nnoremap <leader>l :TlistClose<CR>:TlistToggle<CR>
nnoremap <leader>L :TlistClose<CR>
" quit Vim when the TagList window is the last open window
let Tlist_Exit_OnlyWindow=1 " quit when TagList is the last open window
let Tlist_GainFocus_On_ToggleOpen=1 " put focus on the TagList window when it opens
"let Tlist_Process_File_Always=1 " process files in the background, even when the TagList window isn't open
"let Tlist_Show_One_File=1 " only show tags from the current buffer, not all open buffers
let Tlist_WinWidth=40 " set the width
let Tlist_Inc_Winwidth=1 " increase window by 1 when growing
" shorten the time it takes to highlight the current tag (default is 4 secs)
" note that this setting influences Vim's behaviour when saving swap files,
" but we have already turned off swap files (earlier)
"set updatetime=1000
" the default ctags in /usr/bin on the Mac is GNU ctags, so change it to the
" exuberant ctags version in /usr/local/bin
let Tlist_Ctags_Cmd = '/usr/local/bin/ctags'
" show function/method prototypes in the list
let Tlist_Display_Prototype=1
" don't show scope info
let Tlist_Display_Tag_Scope=0
" show TagList window on the right
let Tlist_Use_Right_Window=1
" }}}
" vim-flake8 default configuration
let g:flake8_max_line_length=120
" Conflict markers {{{
" highlight conflict markers
match ErrorMsg '^\(<\|=\|>\)\{7\}\([^=].\+\)\?$'
" shortcut to jump to next conflict marker
nnoremap <silent> <leader>c /^\(<\\|=\\|>\)\{7\}\([^=].\+\)\?$<CR>
" }}}
" Filetype specific handling {{{
" only do this part when compiled with support for autocommands
if has("autocmd")
augroup invisible_chars "{{{
au!
" Show invisible characters in all of these files
autocmd filetype vim setlocal list
autocmd filetype python,rst setlocal list
autocmd filetype ruby setlocal list
autocmd filetype javascript,css setlocal list
augroup end "}}}
augroup vim_files "{{{
au!
" Bind <F1> to show the keyword under cursor
" general help can still be entered manually, with :h
autocmd filetype vim noremap <buffer> <F1> <Esc>:help <C-r><C-w><CR>
autocmd filetype vim noremap! <buffer> <F1> <Esc>:help <C-r><C-w><CR>
augroup end "}}}
augroup html_files "{{{
au!
" This function detects, based on HTML content, whether this is a
" Django template, or a plain HTML file, and sets filetype accordingly
fun! s:DetectHTMLVariant()
let n = 1
while n < 50 && n < line("$")
" check for django
if getline(n) =~ '{%\s*\(extends\|load\|block\|if\|for\|include\|trans\)\>'
set ft=htmldjango.html
return
endif
let n = n + 1
endwhile
" go with html
set ft=html
endfun
autocmd BufNewFile,BufRead *.html,*.htm,*.j2 call s:DetectHTMLVariant()
" Auto-closing of HTML/XML tags
let g:closetag_default_xml=1
autocmd filetype html,htmldjango let b:closetag_html_style=1
autocmd filetype html,xhtml,xml source ~/.vim/scripts/closetag.vim
augroup end " }}}
augroup python_files "{{{
au!
" This function detects, based on Python content, whether this is a
" Django file, which may enabling snippet completion for it
fun! s:DetectPythonVariant()
let n = 1
while n < 50 && n < line("$")
" check for django
if getline(n) =~ 'import\s\+\<django\>' || getline(n) =~ 'from\s\+\<django\>\s\+import'
set ft=python.django
"set syntax=python
return
endif
let n = n + 1
endwhile
" go with html
set ft=python
endfun
autocmd BufNewFile,BufRead *.py call s:DetectPythonVariant()
" PEP8 compliance (set 1 tab = 4 chars explicitly, even if set
" earlier, as it is important)
autocmd filetype python setlocal expandtab shiftwidth=4 tabstop=4 softtabstop=4
autocmd filetype python setlocal textwidth=78
autocmd filetype python match ErrorMsg '\%>120v.\+'
" But disable autowrapping as it is super annoying
autocmd filetype python setlocal formatoptions-=t
" Folding for Python (uses syntax/python.vim for fold definitions)
"autocmd filetype python,rst setlocal nofoldenable
"autocmd filetype python setlocal foldmethod=expr
" Python runners
autocmd filetype python noremap <buffer> <F5> :w<CR>:!python %<CR>
autocmd filetype python inoremap <buffer> <F5> <Esc>:w<CR>:!python %<CR>
autocmd filetype python noremap <buffer> <S-F5> :w<CR>:!ipython %<CR>
autocmd filetype python inoremap <buffer> <S-F5> <Esc>:w<CR>:!ipython %<CR>
" Automatic insertion of breakpoints
autocmd filetype python nnoremap <buffer> <leader>bp :normal Oimport pdb; pdb.set_trace()<Esc>
" Toggling True/False
autocmd filetype python nnoremap <silent> <C-t> mmviw:s/True\\|False/\={'True':'False','False':'True'}[submatch(0)]/<CR>`m:nohlsearch<CR>
" Run a quick static syntax check every time we save a Python file
autocmd BufWritePost *.py call Flake8()
augroup end " }}}
augroup supervisord_files "{{{
au!
autocmd BufNewFile,BufRead supervisord.conf set ft=dosini
augroup end " }}}
augroup markdown_files "{{{
au!
autocmd filetype markdown noremap <buffer> <leader>p :w<CR>:!open -a Marked %<CR><CR>
augroup end " }}}
augroup ruby_files "{{{
au!
autocmd filetype ruby setlocal expandtab shiftwidth=2 tabstop=2 softtabstop=2
augroup end " }}}
augroup rst_files "{{{
au!
" Auto-wrap text around 74 chars
autocmd filetype rst setlocal textwidth=74
autocmd filetype rst setlocal formatoptions+=nqt
autocmd filetype rst match ErrorMsg '\%>74v.\+'
augroup end " }}}
augroup css_files "{{{
au!
autocmd filetype css,less setlocal foldmethod=marker foldmarker={,}
augroup end "}}}
augroup javascript_files "{{{
au!
autocmd filetype javascript setlocal expandtab
autocmd filetype javascript setlocal listchars=trail:·,extends:#,nbsp:·
autocmd filetype javascript setlocal foldmethod=marker foldmarker={,}
" Toggling True/False
autocmd filetype javascript nnoremap <silent> <C-t> mmviw:s/true\\|false/\={'true':'false','false':'true'}[submatch(0)]/<CR>`m:nohlsearch<CR>
augroup end "}}}
augroup textile_files "{{{
au!
autocmd filetype textile set tw=78 wrap
" Render YAML front matter inside Textile documents as comments
autocmd filetype textile syntax region frontmatter start=/\%^---$/ end=/^---$/
autocmd filetype textile highlight link frontmatter Comment
augroup end "}}}
endif
" }}}
" Skeleton processing {{{
if has("autocmd")
"if !exists('*LoadTemplate')
"function LoadTemplate(file)
"" Add skeleton fillings for Python (normal and unittest) files
"if a:file =~ 'test_.*\.py$'
"execute "0r ~/.vim/skeleton/test_template.py"
"elseif a:file =~ '.*\.py$'
"execute "0r ~/.vim/skeleton/template.py"
"endif
"endfunction
"endif
"autocmd BufNewFile * call LoadTemplate(@%)
endif " has("autocmd")
" }}}
" Restore cursor position upon reopening files {{{
autocmd BufReadPost *
\ if line("'\"") > 0 && line("'\"") <= line("$") |
\ exe "normal! g`\"" |
\ endif
" }}}
" Common abbreviations / misspellings {{{
source ~/.vim/autocorrect.vim
" }}}
" Extra vi-compatibility {{{
" set extra vi-compatible options
set cpoptions+=$ " when changing a line, don't redisplay, but put a '$' at
" the end during the change
set formatoptions-=o " don't start new lines w/ comment leader on pressing 'o'
au filetype vim set formatoptions-=o
" somehow, during vim filetype detection, this gets set
" for vim files, so explicitly unset it again
" }}}
" Extra user or machine specific settings {{{
source ~/.vim/user.vim
" }}}
" Creating underline/overline headings for markup languages
" Inspired by http://sphinx.pocoo.org/rest.html#sections
nnoremap <leader>1 yyPVr=jyypVr=
nnoremap <leader>2 yyPVr*jyypVr*
nnoremap <leader>3 yypVr=
nnoremap <leader>4 yypVr-
nnoremap <leader>5 yypVr^
nnoremap <leader>6 yypVr"
iab lorem Lorem ipsum dolor sit amet, consectetur adipiscing elit
iab llorem Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam lacus ligula, accumsan id imperdiet rhoncus, dapibus vitae arcu. Nulla non quam erat, luctus consequat nisi
iab lllorem Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam lacus ligula, accumsan id imperdiet rhoncus, dapibus vitae arcu. Nulla non quam erat, luctus consequat nisi. Integer hendrerit lacus sagittis erat fermentum tincidunt. Cras vel dui neque. In sagittis commodo luctus. Mauris non metus dolor, ut suscipit dui. Aliquam mauris lacus, laoreet et consequat quis, bibendum id ipsum. Donec gravida, diam id imperdiet cursus, nunc nisl bibendum sapien, eget tempor neque elit in tortor
if has("gui_running")
"set guifont=saxMono:h14 linespace=3
set guifont=Anonymous\ for\ Powerline:h12 linespace=2
"set guifont=Mensch\ for\ Powerline:h14 linespace=0
"set guifont=Droid\ Sans\ Mono:h14 linespace=0
"set guifont=Ubuntu\ Mono:h18 linespace=3
"colorscheme molokai
"colorscheme railscat
"colorscheme kellys
"colorscheme wombat256
"colorscheme mustang
"colorscheme mustang_silent
colorscheme badwolf
" Remove toolbar, left scrollbar and right scrollbar
set guioptions-=T
set guioptions-=l
set guioptions-=L
set guioptions-=r
set guioptions-=R
else
set bg=dark
"colorscheme mustang_silent
"colorscheme molokai
"colorscheme railscat
"colorscheme kellys
"colorscheme molokai_deep
"colorscheme wombat256
"colorscheme mustang
"colorscheme mustang_silent
colorscheme badwolf
endif
" Pulse ------------------------------------------------------------------- {{{
function! PulseCursorLine()
let current_window = winnr()
windo set nocursorline
execute current_window . 'wincmd w'
setlocal cursorline
redir => old_hi
silent execute 'hi CursorLine'
redir END
let old_hi = split(old_hi, '\n')[0]
let old_hi = substitute(old_hi, 'xxx', '', '')
hi CursorLine guibg=#3a3a3a
redraw
sleep 20m
hi CursorLine guibg=#4a4a4a
redraw
sleep 30m
hi CursorLine guibg=#3a3a3a
redraw
sleep 30m
hi CursorLine guibg=#2a2a2a
redraw
sleep 20m
execute 'hi ' . old_hi
windo set cursorline
execute current_window . 'wincmd w'
endfunction
" }}}
" Powerline configuration ------------------------------------------------- {{{
"let g:Powerline_symbols = 'compatible'
let g:Powerline_symbols = 'fancy'
" }}}
" Python mode configuration ----------------------------------------------- {{{
" Don't run pylint on every save
let g:pymode_lint = 0
let g:pymode_lint_write = 0
" }}}
" Learn Vim Script the Hard Way Exercises
"noremap - ddp
"noremap _ ddkP
" C-U in insert/normal mode, to uppercase the word under cursor
inoremap <c-u> <esc>viwUea
nnoremap <c-u> viwUe
iabbr m@@ me@nvie.com
iabbr v@@ vincent@3rdcloud.com
iabbr ssig --<cr>Vincent Driessen<cr>vincent@3rdcloud.com
" Quote words under cursor
nnoremap <leader>" viw<esc>a"<esc>hbi"<esc>lel
nnoremap <leader>' viw<esc>a'<esc>hbi'<esc>lel
" Quote current selection
" TODO: This only works for selections that are created "forwardly"
vnoremap <leader>" <esc>a"<esc>gvo<esc>i"<esc>gvo<esc>ll
vnoremap <leader>' <esc>a'<esc>gvo<esc>i'<esc>gvo<esc>ll
" Use shift-H and shift-L for move to beginning/end
nnoremap H 0
nnoremap L $
" Define operator-pending mappings to quickly apply commands to function names
" and/or parameter lists in the current line
onoremap inf :<c-u>normal! 0f(hviw<cr>
onoremap anf :<c-u>normal! 0f(hvaw<cr>
onoremap in( :<c-u>normal! 0f(vi(<cr>
onoremap an( :<c-u>normal! 0f(va(<cr>
" "Next" tag
onoremap int :<c-u>normal! 0f<vit<cr>
onoremap ant :<c-u>normal! 0f<vat<cr>
" Function argument selection (change "around argument", change "inside argument")
onoremap ia :<c-u>execute "normal! ?[,(]\rwv/[),]\rh"<cr>
vnoremap ia :<c-u>execute "normal! ?[,(]\rwv/[),]\rh"<cr>
" Split previously opened file ('#') in a split window
nnoremap <leader>sh :execute "leftabove vsplit" bufname('#')<cr>
nnoremap <leader>sl :execute "rightbelow vsplit" bufname('#')<cr>
" Grep searches
"nnoremap <leader>g :silent execute "grep! -R " . shellescape('<cword>') . " ."<cr>:copen 12<cr>
"nnoremap <leader>G :silent execute "grep! -R " . shellescape('<cWORD>') . " ."<cr>:copen 12<cr>
" Run tests
inoremap <leader>w <esc>:write<cr>:!./run_tests.sh %<cr>
nnoremap <leader>w :!./run_tests.sh<cr>
Jump to Line
Something went wrong with that request. Please try again.