aboutsummaryrefslogblamecommitdiff
path: root/vim/vimrc
blob: 724a32e7f34ce591ba0e67d19298464a7a67cf33 (plain) (tree)
1
2
3
4
5
6
                                                                       
                                       
 


                                                            








                                                            
                                           
                 
                            


                           
                                         
                
 
                           


                           
 
                                                                



                                       







                                                                     


                       

     
                                                               



                                                             
 
                                            
                                    
                                                 
                                                       
 
                                                   
          
                                         
 
                               

                                                      

                                                            
     
 



                                   


                                                            
 





                                                                  


                                                                  



                                         
                                                     
                                         
 


                                                                  
     
 
                                                  



                     
 





                                           
                                                         


                                                         

                                                   
                                                  
                                            
     
 




                                                  


                                                       

                                           
 

                                               
          
 
                                                       
            
 


                                          

                                                    
                   

                  
 
                                                

              
                                
             
 
                                        




                                                           
 
                                                
              
 
                                                         
                    
 

                                                          
                                                               
 

                                                


             
 





                                                                   

                                              
 
                                     
                 
 


                                                       
 
                                     

                                                      

               
 
                                                     
                         
              
                                         

     
                                                   




                                                          
 
                                                     
                         


                        


                    
                                                             

                                                   
 
                                                          
                                                                        

                                 
 


                                                          
                                          
                           

                                                                             
                                 
     
 

                                                      
                           
 


                              
                             

                         
                       

                          
                                         

                          
                                   

                          
 
                                        

                                        
 
                                                    
                                                            
 
                                              
                                          
 
                                                                
                                                             
                                                 

                                                                   
 
                                        
                                  
                                      
                                     
 
                                   
                                                           
 
                                                  
                                                    
 
                             
                                                             
 
                                                     
                                           
 
                                        
                                                    
 
                          
                                      
 
                                                  
                                                      
 
                               
                                                  
 
                   
                                  
 
                                                              

                                                   
 
                      
                                
                                   
                                         
 
                                

                                                       
                                             

                                                
 
                                     
                                     
                                     
                                     
 
                       
                                              
 
                                  
                       
 
                                   

                                      
 
                     
                                            
 
                           
                                                   
 
                           
                                               
                    
                                               
 
                                          
                                                     
 
                               
                                      
                              
                                         
 
                     

                                                   
 
                                                   

                                           
 
                                                      

                                       
 
                        
                                      
 
                                          
                                                     
 
                                                         
                                                      
                                                          
                                                       
 
                                                            
                                   
 
                                                        

                                         
 
                                                               
                                          
 
                                            
                                         
 
                                                                    





                                         
 
                                                          
                                                                

                                                            
 



                                  
                                 
                                      
                         
                                        
 


                                                       
                           
                                  
                                    
                               
                                     
 
                                          
                     
" Tom Ryder (tejr)'s vimrc: <https://sanctum.geek.nz/cgit/dotfiles.git>
" Requires Vim 7.0 or newer with +eval.

" Undo anything the operating system's vimrc may have broken
runtime system.vim

" Set an environment variable for the user runtime directory
if !exists('$MYVIMRUNTIME')
  if has('win32') || has('win64')
    let $MYVIMRUNTIME = expand('~/vimfiles')
  else
    let $MYVIMRUNTIME = expand('~/.vim')
  endif
endif

" Load filetype settings, plugins, and maps
if has('autocmd')
  let g:maplocalleader = ','
  filetype plugin indent on
endif

" Options dependent on the syntax feature
if has('syntax')

  " Use syntax highlighting
  if !exists('g:syntax_on')
    syntax enable
  endif

  " Use my colorscheme if using the GUI or if we have 256 colors
  if has('gui_running') || &t_Co >= 256
    silent! colorscheme sahara
  endif

  " If my colorscheme loaded, turn on subtle 'cursorline' coloring
  if exists('g:colors_name') && g:colors_name ==# 'sahara'
    if exists('+cursorline')
      set cursorline
    endif

  " If it didn't load, default to default scheme with dark background
  else
    set background=dark
  endif

endif

" The all-important default indent settings; filetypes to tweak
set autoindent     " Use indent of previous line on new lines
set expandtab      " Use spaces instead of tabs
set shiftwidth=4   " Indent with four spaces
set softtabstop=4  " Insert four spaces with tab key

" Let me backspace over pretty much anything
set backspace+=eol     " Line breaks
set backspace+=indent  " Spaces from 'autoindent'
set backspace+=start   " The start of current insertion

" Try to keep backups in one system-appropriate dir
set backup
set backupdir^=$MYVIMRUNTIME/cache/backup

" Add some paths not to back up
if has('unix')
  set backupskip^=/dev/shm/*  " Shared memory RAM disk
  set backupskip^=/usr/tmp/*  " Hardcoded path for `sudo -e`
  set backupskip^=/var/tmp/*  " Hardcoded path for `sudo -e`
endif

" Indent wrapped lines if supported
if exists('+breakindent')
  set breakindent
endif

" Clear default 'comments' value, let the filetype handle it
set comments=

" Add completion options
if exists('+completeopt')
  set completeopt+=longest  " Insert longest common substring
  set completeopt+=menuone  " Show the menu even if only one match
endif

" Give me a prompt instead of just rejecting risky :write, :saveas
set confirm

" Require two spaces for sentence objects
" Yes, I have become a filthy two-spacer
set cpoptions+=J

" Try to keep swapfiles in one system-appropriate dir
set directory^=$MYVIMRUNTIME/cache/swap//

" Use UTF-8 if we can and env LANG didn't tell us not to
if has('multi_byte') && !exists('$LANG') && &encoding ==# 'latin1'
  set encoding=utf-8
endif

" Don't wait for a key after Escape in insert mode
" Not in NeoVim
if exists('+esckeys')
  set noesckeys
endif

" Fold based on indent, but only when I ask
if has('folding')
  set foldlevelstart=99
  set foldmethod=indent
endif

" Delete comment leaders when joining lines, if supported
if v:version > 703 || v:version == 703 && has('patch541')
  set formatoptions+=j
endif

" If available, use GNU grep niceties for searching
if system('grep --version') =~# '^grep (GNU grep)'
  set grepprg=grep\ -HnRs\ --exclude='.git*'
endif

" Don't load GUI menus; set here before GUI starts
if has('gui_running')
  set guioptions+=M
endif

" Allow buffers to have changes without being displayed
set hidden

" Keep much more command and search history
set history=2000

" Highlight completed searches; clear on reload
set hlsearch
nohlsearch

" Don't assume I'm editing C; let the filetype set this
set include=

" Show search matches as I type my pattern
set incsearch

" Don't show a statusline if there's only one window
" This is the Vim default, but NeoVim changed it
if &laststatus != 1
  set laststatus=1
endif

" Don't redraw the screen during batch execution
set lazyredraw

" Break lines at word boundaries
set linebreak

" Define extra 'list' display characters
set listchars+=extends:>   " Unwrapped text to screen right
set listchars+=precedes:<  " Unwrapped text to screen left
set listchars+=tab:>-      " Tab characters, preserve width
set listchars+=trail:_     " Trailing spaces
set listchars+=nbsp:+      " Non-breaking spaces

" Don't allow setting options via buffer content
set nomodeline

" Treat numbers with a leading zero as decimal, not octal
set nrformats-=octal

" Options for file search with gf/:find
set path-=/usr/include  " Let the C/C++ filetypes set that
set path+=**            " Search current directory's whole tree

" Disable command line display of file position
" This is the Vim default, but NeoVim changed it
if &ruler
  set noruler
endif

" Make sessions usable
if exists('+sessionoptions')
  set sessionoptions-=localoptions  " No buffer options or mappings
  set sessionoptions-=options       " No global options or mappings
endif

" Don't show startup splash screen (I donated)
set shortmess+=I

" Prefix wrapped rows with three dots
set showbreak=...

" New window positioning
set splitbelow  " Below the current window, not above
set splitright  " Right of the current window, not left

" No terminal mouse, even if we could
" The manual says to set 't_RV', but I don't like that
if exists('+ttymouse') && &ttymouse !=# ''
  set ttymouse=
endif

" Keep undo files, hopefully in a dedicated directory
if has('persistent_undo')
  set undofile
  set undodir^=$MYVIMRUNTIME/cache/undo//
endif

" Wildmenu settings; see also plugin/wildignore.vim
set wildmenu               " Use wildmenu
set wildmode=list:longest  " Tab press completes and lists
if exists('+wildignorecase')
  set wildignorecase  " Case insensitive, if supported
endif

" Let me move beyond buffer text in visual block mode
if exists('+virtualedit')
  set virtualedit+=block
endif

" Never beep at me
set visualbell t_vb=

" Stack normal/visual/select Ctrl-L to clear search highlight
nnoremap <silent> <C-L> :<C-U>nohlsearch<CR><C-L>
vnoremap <silent> <C-L> :<C-U>nohlsearch<CR>gv<C-L>

" Remap insert Ctrl-C to undo the escaped insert operation
if &loadplugins  " Don't break the key if we won't be loading the plugin
  imap <C-C> <Plug>(InsertCancel)
endif

" Map double Ctrl-K in insert mode to search digraph names
imap <C-K><C-K> <Plug>(DigraphSearch)

" Remap normal space to scroll down a page
nnoremap <Space> <PageDown>
" Do a :next after hitting the last line
if &loadplugins  " Don't change the mapping if we won't be loading the plugin
  nmap <Space> <Plug>(ScrollNext)
endif

" Remap normal/visual & to preserve substitution flags
nnoremap <silent> & :&&<CR>
xnoremap <silent> & :&&<CR>

" Map g: as a 'colon operator'
nmap g: <Plug>(ColonOperator)

" Cycle through argument list
nnoremap [a :previous<CR>
nnoremap ]a :next<CR>
" Cycle through buffers
nnoremap [b :bprevious<CR>
nnoremap ]b :bnext<CR>
" Cycle through quicklist/:helpgrep items
nnoremap [c :cprevious<CR>
nnoremap ]c :cnext<CR>
" Cycle through location list items
nnoremap [l :lprevious<CR>
nnoremap ]l :lnext<CR>

" Insert blank lines around current line
nmap [<Space> <Plug>(PutBlankLinesAbove)
nmap ]<Space> <Plug>(PutBlankLinesBelow)

" \a toggles 'formatoptions' 'a' flag using a plugin
nnoremap <Leader>a :<C-U>ToggleFlagLocal formatoptions a<CR>

" \b toggles copy-pasteable linebreak settings
nmap <Leader>b <Plug>(CopyLinebreakToggle)

" \c toggles 'cursorline'; no visual mode map as it doesn't work
nnoremap <Leader>c :<C-U>setlocal cursorline! cursorline?<CR>
" \C toggles 'cursorcolumn'; works in visual mode
nnoremap <Leader>C :<C-U>setlocal cursorcolumn! cursorcolumn?<CR>
xnoremap <Leader>C :<C-U>setlocal cursorcolumn! cursorcolumn?<CR>gv

" \d inserts the local date (POSIX date)
nnoremap <Leader>d :read !date<CR>
" \D inserts the UTC date (POSIX date)
nnoremap <Leader>D :read !date -u<CR>

" \e forces a buffer to be editable
nnoremap <Leader>e :<C-U>setlocal modifiable noreadonly<CR>

" \f shows the current 'formatoptions' at a glance
nnoremap <Leader>f :<C-U>setlocal formatoptions?<CR>

" \F reloads filetype plugins
nnoremap <Leader>F :<C-U>doautocmd filetypedetect BufRead<CR>

" \g changes directory to the current file's location
nnoremap <Leader>g :<C-U>cd %:h<CR>:pwd<CR>

" \h toggles highlighting search results
nnoremap <Leader>h :<C-U>set hlsearch! hlsearch?<CR>

" \H shows command history
nnoremap <Leader>H :<C-U>history :<CR>

" \i toggles showing matches as I enter my pattern
nnoremap <Leader>i :<C-U>set incsearch! incsearch?<CR>

" \j jumps to buffers (jetpack)
nnoremap <Leader>j :<C-U>buffers<CR>:buffer<Space>

" \k shows my marks
nnoremap <Leader>k :<C-U>marks<CR>

" \l toggles showing tab, end-of-line, and trailing whitespace
nnoremap <Leader>l :<C-U>setlocal list! list?<CR>
xnoremap <Leader>l :<C-U>setlocal list! list?<CR>gv

" \m shows normal maps
nnoremap <Leader>m :<C-U>map<CR>
" \M shows buffer-local normal maps
nnoremap <Leader>M :<C-U>map <buffer><CR>

" \n toggles line number display
nnoremap <Leader>n :<C-U>setlocal number! number?<CR>
xnoremap <Leader>n :<C-U>setlocal number! number?<CR>gv
" \N toggles position display in bottom right
nnoremap <Leader>N :<C-U>set ruler! ruler?<CR>
xnoremap <Leader>N :<C-U>set ruler! ruler?<CR>gv

" \o opens a line below in paste mode
nmap <Leader>o <Plug>(PasteOpenBelow)
" \O opens a line above in paste mode
nmap <Leader>O <Plug>(PasteOpenAbove)

" \p toggles paste mode
nnoremap <Leader>p :<C-U>set paste! paste?<CR>

" \q formats the current paragraph
nnoremap <Leader>q gqap

" \r acts as a replacement operator
nmap <Leader>r <Plug>(ReplaceOperator)
xmap <Leader>r <Plug>(ReplaceOperator)

" \R reloads ~/.vimrc
nnoremap <Leader>R :<C-U>source $MYVIMRC<CR>

" \s toggles spell checking
nnoremap <Leader>s :<C-U>setlocal spell! spell?<CR>

" \t shows current filetype
nnoremap <Leader>t :<C-U>setlocal filetype?<CR>
" \T clears filetype
nnoremap <Leader>T :<C-U>setlocal filetype=<CR>

" \u sets US English spelling (compare \z)
nnoremap <Leader>u :<C-U>setlocal spelllang=en_us<CR>

" \v shows all global variables
nnoremap <Leader>v :<C-U>let g: v:<CR>
" \V shows all local variables
nnoremap <Leader>V :<C-U>let b: t: w:<CR>

" \w toggles wrapping
nnoremap <Leader>w :<C-U>setlocal wrap! wrap?<CR>
xnoremap <Leader>w :<C-U>setlocal wrap! wrap?<CR>gv

" \x strips trailing whitespace via a custom plugin
nmap <Leader>x :StripTrailingWhitespace<CR>
xmap <Leader>x :StripTrailingWhitespace<CR>

" \X squeezes repeated blank lines via a custom plugin
nmap <Leader>X :SqueezeRepeatBlanks<CR>
xmap <Leader>X :SqueezeRepeatBlanks<CR>

" \y shows all registers
nnoremap <Leader>y :<C-U>registers<CR>

" \z sets NZ English spelling (compare \u)
nnoremap <Leader>z :<C-U>setlocal spelllang=en_nz<CR>

" \= runs the whole buffer through =, preserving position
nnoremap <Leader>= :<C-U>call vimrc#Anchor('1G=G')<CR>
" \+ runs the whole buffer through gq, preserving position
nnoremap <Leader>+ :<C-U>call vimrc#Anchor('1GgqG')<CR>

" \. runs the configured make program into the location list
nnoremap <Leader>. :<C-U>lmake!<CR>

" \< and \> adjust indent of last edit; good for pasting
nnoremap <Leader><lt> :<C-U>'[,']<lt><CR>
nnoremap <Leader>> :<C-U>'[,']><CR>

" \_ uses last changed or yanked text as a characterwise object
onoremap <Leader>_ :<C-U>normal! `[v`]<CR>

" \% uses entire buffer as a linewise object
onoremap <Leader>% :<C-U>normal! 1GVG<CR>

" \{ and \} move to lines with non-space chars before current column
nmap <Leader>{ <Plug>(VerticalRegionUp)
nmap <Leader>} <Plug>(VerticalRegionDown)
omap <Leader>{ <Plug>(VerticalRegionUp)
omap <Leader>} <Plug>(VerticalRegionDown)
xmap <Leader>{ <Plug>(VerticalRegionUp)
xmap <Leader>} <Plug>(VerticalRegionDown)

" \/ types :vimgrep for me ready to enter a search pattern
nnoremap <Leader>/ :<C-U>vimgrep /\c/j **<S-Left><S-Left><Right>
" \? types :lhelpgrep for me ready to enter a search pattern
nnoremap <Leader>? :<C-U>lhelpgrep \c<S-Left>

" \\ escapes regex metacharacters
nmap <Leader>\ <Plug>(RegexEscape)
xmap <Leader>\ <Plug>(RegexEscape)

" \DEL deletes the current buffer
nnoremap <Leader><Delete> :bdelete<CR>
" \INS edits a new buffer
nnoremap <Leader><Insert> :<C-U>enew<CR>

" Execution mappings; each of these clobbers register z

" \@ executes line in normal mode
nnoremap <Leader>@ ^"zyg_@z
" \: executes line in command mode
nnoremap <Leader>: ^"zyg_:<C-R>z<CR>
" \! executes line with 'shell'
nnoremap <Leader>! ^"zyg_:!<C-R>z<CR>

" Source any .vim files from ~/.vim/config
runtime! config/*.vim