.vimrc

" General {{{

" use indentation for folds
set foldmethod=indent
set foldnestmax=5
set foldlevelstart=99
set foldcolumn=0


" Sets how many lines of history VIM has to remember
set history=700

" Set to auto read when a file is changed from the outside
set autoread

" With a map leader it's possible to do extra key combinations
" like <leader>w saves the current file
let mapleader = ","
let g:mapleader = ","

" Leader key timeout
set tm=2000

" Allow the normal use of "," by pressing it twice
noremap ,, ,

" Use par for prettier line formatting
" set formatprg="PARINIT='rTbgqR B=.,?_A_a Q=_s>|' par\ -w72"

" Use stylish haskell instead of par for haskell buffers
" TODO: stylish-haskell doesn't compile.
" autocmd FileType haskell let &formatprg="stylish-haskell"

" Makefiles
autocmd filetype make setlocal noexpandtab

" Find custom built ghc-mod, codex etc
"let $PATH = $PATH . ':' . expand("~/.vim/haskell/bin")

" Kill the damned Ex mode.
nnoremap Q <nop>

" }}}

" Vundle {{{

set nocompatible
filetype off
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()

" let Vundle manage Vundle
" required!
Plugin 'gmarik/Vundle.vim'

" Support bundles
Plugin 'jgdavey/tslime.vim'
Plugin 'Shougo/vimproc.vim'
Plugin 'ervandew/supertab'
"Plugin 'scrooloose/syntastic' " Syntax checker; a little too enthusiastic.
Plugin 'moll/vim-bbye'
Plugin 'nathanaelkane/vim-indent-guides'
Plugin 'vim-scripts/gitignore'

" Git
Plugin 'tpope/vim-fugitive'
Plugin 'int3/vim-extradite'
"Plugin 'airblade/vim-gitgutter'

" Bars, panels, and files
Plugin 'scrooloose/nerdtree'
Plugin 'bling/vim-airline'
Plugin 'kien/ctrlp.vim'
"Plugin 'majutsushi/tagbar'

" Text manipulation
"Plugin 'vim-scripts/Align'
Plugin 'vim-scripts/Gundo'
Plugin 'tpope/vim-commentary'
Plugin 'godlygeek/tabular'
Plugin 'michaeljsmith/vim-indent-object'
Plugin 'tpope/tpope-vim-abolish' " Subvert, eg. :%S/foo/bar/, preserves case

" Allow pane movement to jump out of vim into tmux
Plugin 'christoomey/vim-tmux-navigator'

" Haskell
Plugin 'raichoo/haskell-vim'
"Plugin 'enomsg/vim-haskellConcealPlus' " Unicode abbreviations of ->, true, forAll, etc.
Plugin 'Twinside/vim-hoogle'
"Plugin 'eagletmt/ghcmod-vim'
"Plugin 'eagletmt/neco-ghc'

" Purescript
Plugin 'raichoo/purescript-vim'
Plugin 'frigoeu/psc-ide-vim'

" Elm
Plugin 'lambdatoast/elm.vim'

" Elixir
Plugin 'elixir-editors/vim-elixir'
Plugin 'slashmili/alchemist.vim'

" Machinator
Plugin 'damncabbage/machinator-vim'

" TypeScript
Plugin 'HerringtonDarkholme/yats.vim'

" Colorschemes
"Plugin 'vim-scripts/wombat256.vim'
Plugin 'tssm/fairyfloss.vim'

" Session management
Plugin 'thaerkh/vim-workspace'

" Build
Plugin 'neomake/neomake'

" Custom bundles
if filereadable(expand("~/.vim.local/bundles.vim"))
  source ~/.vim.local/bundles.vim
endif

call vundle#end()

" }}}

" VIM user interface {{{

" Indent/deindent v-selected lines, retaining selection for further indentation.
vmap <Tab> >gv
vmap <S-Tab> <gv

" Set 7 lines to the cursor - when moving vertically using j/k
"set so=7
set so=0

" Turn on the WiLd menu
set wildmenu
" Tab-complete files up to longest unambiguous prefix
set wildmode=list:longest,full

" Always show current position
set ruler
"set number " Line Numbers

" Show trailing whitespace
highlight default BadWhitespace ctermbg=red guibg=red
autocmd ColorScheme <buffer> highlight default BadWhitespace ctermbg=red guibg=red
match BadWhitespace /\s\+$/
"set list
"" But only interesting whitespace
"if &listchars ==# 'eol:$'
"  set listchars=tab:>\ ,trail:-,extends:>,precedes:<,nbsp:+
"endif

" Height of the command bar
set cmdheight=1

" Configure backspace so it acts as it should act
set backspace=eol,start,indent
set whichwrap+=<,>,h,l

" Ignore case when searching
"set ignorecase

" When searching try to be smart about cases
"set smartcase

" Highlight search results
set hlsearch

" Makes search act like search in modern browsers
"set incsearch

" Don't redraw while executing macros (good performance config)
set lazyredraw

" For regular expressions turn magic on
set magic

" Show matching brackets when text indicator is over them
set showmatch
" How many tenths of a second to blink when matching brackets
set mat=2

" No annoying sound on errors
set noerrorbells
set vb t_vb=

if &term =~ '256color'
  " disable Background Color Erase (BCE) so that color schemes
  " render properly when inside 256-color tmux and GNU screen.
  " see also http://snk.tuxfamily.org/log/vim-256color-bce.html
  set t_ut=
endif

" Force redraw
map <silent> <leader>r :redraw!<CR>

" Turn mouse mode on
nnoremap <leader>m :set mouse=a<cr>

" Previous mouse settings:
"" Turn mouse mode on
"nnoremap <leader>ma :set mouse=a<cr>
"" Turn mouse mode off
"nnoremap <leader>mo :set mouse=<cr>
"" Default to mouse mode on
"set mouse=a

" }}}

" Colors and Fonts {{{

colorscheme fairyfloss
hi Underlined guifg=#fff352 guibg=NONE gui=underline ctermfg=0
"try
"  "colorscheme wombat256mod
"  colorscheme zenburn
"  hi Visual    ctermbg=232 " Colourscheme hacks; originally 235.
"  hi VisualNOS ctermbg=232
"catch
"endtry

" Enable syntax highlighting
syntax enable

" Adjust signscolumn and syntastic to match wombat
hi! link SignColumn LineNr
hi! link SyntasticErrorSign ErrorMsg
hi! link SyntasticWarningSign WarningMsg

" Use pleasant but very visible search hilighting
hi Search ctermfg=white ctermbg=173 cterm=none guifg=#ffffff guibg=#e5786d gui=none
hi! link Visual Search

" Enable filetype plugins
filetype plugin on
filetype indent on

" Match wombat colors in nerd tree
hi Directory guifg=#8ac6f2

" Searing red very visible cursor
hi Cursor guibg=red

" Use same color behind concealed unicode characters
hi clear Conceal

" Don't blink normal mode cursor
set guicursor=n-v-c:block-Cursor
set guicursor+=n-v-c:blinkon0

" Set extra options when running in GUI mode
if has("gui_running")
  set guioptions-=T
  set guioptions-=e
  set guitablabel=%M\ %t
endif
set t_Co=256
set termguicolors

" Set utf8 as standard encoding and en_US as the standard language
set encoding=utf8

" Use Unix as the standard file type
set ffs=unix,dos,mac

" Use large font by default in MacVim
set gfn=Monaco:h19

" }}}

" Files, backups and undo {{{

" Turn backup off, since most stuff is in Git anyway...
set nobackup
"set nowb
"set noswapfile

" Source the vimrc file after saving it
augroup sourcing
  autocmd!
  autocmd bufwritepost .vimrc source $MYVIMRC
augroup END

" Open file prompt with current path
nmap <leader>e :e <C-R>=expand("%:p:h") . '/'<CR>

" Show undo tree
nmap <silent> <leader>u :GundoToggle<CR>

" Fuzzy find files
nnoremap <silent> <Leader><space> :CtrlP<CR>
let g:ctrlp_max_files=0
let g:ctrlp_show_hidden=1
let g:ctrlp_custom_ignore = { 'dir': '\v[\/](.git)$' }

" }}}

" Text, tab and indent related {{{

" Use spaces instead of tabs
set expandtab

" Be smart when using tabs ;)
set smarttab

" 1 tab == 2 spaces
set shiftwidth=2
set tabstop=2

" Line-wrap with gq
set tw=500 " tw is textwidth
"au FileType markdown setlocal tw=100 tabstop=2 expandtab shiftwidth=2 softtabstop=2
au FileType markdown setlocal tabstop=2 expandtab shiftwidth=2 softtabstop=2
au FileType elm setlocal tabstop=4 expandtab shiftwidth=4 softtabstop=4

" Avoid line-wrapping in the middle of a word.
set lbr

" Keep some space at the bottom of the window
set scrolloff=3

set ai "Auto indent
"set si "Smart indent
set wrap "Wrap lines

" Pretty unicode haskell symbols
let g:haskell_conceal_wide = 1
let g:haskell_conceal_enumerations = 1

" }}}

" Visual mode related {{{

" Visual mode pressing * or # searches for the current selection
" Super useful! From an idea by Michael Naumann
vnoremap <silent> * :call VisualSelection('f', '')<CR>
vnoremap <silent> # :call VisualSelection('b', '')<CR>

" }}}

" Moving around, tabs, windows and buffers {{{

"" Treat long lines as break lines (useful when moving around in them)
"nnoremap j gj
"nnoremap k gk
"
"noremap <c-h> <c-w>h
"noremap <c-k> <c-w>k
"noremap <c-j> <c-w>j
"noremap <c-l> <c-w>l

" Disable highlight when <leader><cr> is pressed
" but preserve cursor coloring
nmap <silent> <leader><cr> :noh\|hi Cursor guibg=red<cr>
augroup haskell
  autocmd!
  autocmd FileType haskell map <silent> <leader><cr> :noh<cr>:GhcModTypeClear<cr>:SyntasticReset<cr>
  autocmd FileType haskell setlocal omnifunc=necoghc#omnifunc
augroup END

" Return to last edit position when opening files (You want this!)
augroup last_edit
  autocmd!
  autocmd BufReadPost *
       \ if line("'\"") > 0 && line("'\"") <= line("$") |
       \   exe "normal! g`\"" |
       \ endif
augroup END
" Remember info about open buffers on close
set viminfo^=%

" Open window splits in various places
nmap <leader>sh :leftabove  vnew<CR>
nmap <leader>sl :rightbelow vnew<CR>
nmap <leader>sk :leftabove  new<CR>
nmap <leader>sj :rightbelow new<CR>

" Manually create key mappings (to avoid rebinding C-\)
let g:tmux_navigator_no_mappings = 1

"nnoremap <silent> <C-h> :TmuxNavigateLeft<cr>
"nnoremap <silent> <C-j> :TmuxNavigateDown<cr>
"nnoremap <silent> <C-k> :TmuxNavigateUp<cr>
"nnoremap <silent> <C-l> :TmuxNavigateRight<cr>

" don't close buffers when you aren't displaying them
"set hidden

" previous buffer, next buffer
nnoremap <leader>bp :bp<cr>
nnoremap <leader>bn :bn<cr>

" delete buffer without closing pane
noremap <leader>bd :Bd<cr>

" fuzzy find buffers
noremap <leader>b<space> :CtrlPBuffer<cr>

" }}}

" Status line / Airline {{{

" Always show the status line
set laststatus=2
let g:airline#extensions#neomake#enabled = 1
let airline#extensions#neomake#error_symbol = '誤' " 'E:'
let airline#extensions#neomake#warning_symbol = '危' " 'W:'
let g:airline#extensions#default#section_truncate_width = {
    \ 'b': 79,
    \ 'x': 60,
    \ 'y': 88,
    \ 'z': 45,
    \ 'warning': 80,
    \ }
    "\ 'error': 80, " Don't shrink the error.

let g:airline_theme_patch_func = 'AirlineThemePatch'
function! AirlineThemePatch(palette)
  if g:airline_theme == 'dark'
    for mode in keys(a:palette)
      let a:palette[mode]['airline_warning'] = [ '#ffffff', '#e8730d', 232, 166 ]
      let a:palette[mode]['airline_error'] = [ '#ffffff', '#990000', 232, 160 ]
    endfor
  endif
endfunction
" }}}

" Editing mappings {{{

" Delete trailing white space on save
func! DeleteTrailingWS()
  exe "normal mz"
  %s/\s\+$//ge
  exe "normal `z"
endfunc

augroup whitespace
  autocmd!
  autocmd BufWrite *.hs :call DeleteTrailingWS()
augroup END

" }}}

" Spell checking {{{

" Pressing ,ss will toggle and untoggle spell checking
map <leader>ss :setlocal spell!<cr>

" }}}

" Helper functions {{{

function! CmdLine(str)
  exe "menu Foo.Bar :" . a:str
  emenu Foo.Bar
  unmenu Foo
endfunction

function! VisualSelection(direction, extra_filter) range
  let l:saved_reg = @"
  execute "normal! vgvy"

  let l:pattern = escape(@", '\\/.*$^~[]')
  let l:pattern = substitute(l:pattern, "\n$", "", "")

  if a:direction == 'b'
    execute "normal ?" . l:pattern . "^M"
  elseif a:direction == 'gv'
    call CmdLine("vimgrep " . '/'. l:pattern . '/' . ' **/*.' . a:extra_filter)
  elseif a:direction == 'replace'
    call CmdLine("%s" . '/'. l:pattern . '/')
  elseif a:direction == 'f'
    execute "normal /" . l:pattern . "^M"
  endif

  let @/ = l:pattern
  let @" = l:saved_reg
endfunction

" }}}

" Slime {{{

vmap <silent> <Leader>rs <Plug>SendSelectionToTmux
nmap <silent> <Leader>rs <Plug>NormalModeSendToTmux
nmap <silent> <Leader>rv <Plug>SetTmuxVars

" }}}

" NERDTree {{{

" Close nerdtree after a file is selected
let NERDTreeQuitOnOpen = 1

function! IsNERDTreeOpen()
  return exists("t:NERDTreeBufName") && (bufwinnr(t:NERDTreeBufName) != -1)
endfunction

function! ToggleFindNerd()
  if IsNERDTreeOpen()
    exec ':NERDTreeToggle'
  else
    exec ':NERDTreeFind'
  endif
endfunction

" If nerd tree is closed, find current file, if open, close it
nmap <silent> <leader>f <ESC>:call ToggleFindNerd()<CR>
nmap <silent> <leader>F <ESC>:NERDTreeToggle<CR>

" }}}

" Alignment {{{

"" Stop Align plugin from forcing its mappings on us
"let g:loaded_AlignMapsPlugin=1
"" Align on equal signs
"map <Leader>a= :Align =<CR>
"" Align on commas
"map <Leader>a, :Align ,<CR>
"" Align on pipes
"map <Leader>a<bar> :Align <bar><CR>
"" Prompt for align character
"map <leader>ap :Align

" Enable some tabular presets for Haskell
"let g:haskell_tabular = 1

" }}}

" Tags {{{
"""
"""set tags=tags;/,codex.tags;/
"""
"""let g:tagbar_type_haskell = {
"""    \ 'ctagsbin'  : 'hasktags',
"""    \ 'ctagsargs' : '-x -c -o-',
"""    \ 'kinds'     : [
"""        \  'm:modules:0:1',
"""        \  'd:data: 0:1',
"""        \  'd_gadt: data gadt:0:1',
"""        \  't:type names:0:1',
"""        \  'nt:new types:0:1',
"""        \  'c:classes:0:1',
"""        \  'cons:constructors:1:1',
"""        \  'c_gadt:constructor gadt:1:1',
"""        \  'c_a:constructor accessors:1:1',
"""        \  'ft:function types:1:1',
"""        \  'fi:function implementations:0:1',
"""        \  'o:others:0:1'
"""    \ ],
"""    \ 'sro'        : '.',
"""    \ 'kind2scope' : {
"""        \ 'm' : 'module',
"""        \ 'c' : 'class',
"""        \ 'd' : 'data',
"""        \ 't' : 'type'
"""    \ },
"""    \ 'scope2kind' : {
"""        \ 'module' : 'm',
"""        \ 'class'  : 'c',
"""        \ 'data'   : 'd',
"""        \ 'type'   : 't'
"""    \ }
"""\ }
"""
"""" Generate haskell tags with codex and hscope
""""map <leader>tg :!codex update --force<CR>:call system("git hscope -X TemplateHaskell")<CR><CR>:call LoadHscope()<CR>
""""map <leader>tg :!hasktags --ignore-close-implementation --ctags .<CR>
"""map <leader>tg :!codex update --force<CR>
"""
"""map <leader>tt :TagbarToggle<CR>

"set csprg=~/.vim/haskell/bin/hscope
"set csto=1 " search codex tags first
"set cst
"set csverb
"nnoremap <silent> <C-\> :cs find c <C-R>=expand("<cword>")<CR><CR>
"" Automatically make cscope connections
"function! LoadHscope()
"  let db = findfile("hscope.out", ".;")
"  if (!empty(db))
"    let path = strpart(db, 0, match(db, "/hscope.out$"))
"    "echo db
"    "echo path
"    "echo "cs add " . db . " " . path
"    set nocscopeverbose " suppress 'duplicate connection' error
"    exe "cs add " . db . " " . path
"    set cscopeverbose
"  endif
"endfunction
""au BufEnter /*.hs call LoadHscope()

" }}}

" Git {{{

let g:extradite_width = 60
" Hide messy Ggrep output and copen automatically
function! NonintrusiveGitGrep(term)
  execute "copen"
  " Map 't' to open selected item in new tab
  execute "nnoremap <silent> <buffer> t <C-W><CR><C-W>T"
  execute "silent! Ggrep " . a:term
  execute "redraw!"
endfunction

command! -nargs=1 GGrep call NonintrusiveGitGrep(<q-args>)
nmap <leader>gs :Gstatus<CR>
nmap <leader>gg :copen<CR>:GGrep
nmap <leader>gl :Extradite!<CR>
nmap <leader>gd :Gdiff<CR>
nmap <leader>gb :Gblame<CR>

function! CommittedFiles()
  " Clear quickfix list
  let qf_list = []
  " Find files committed in HEAD
  let git_output = system("git diff-tree --no-commit-id --name-only -r HEAD\n")
  for committed_file in split(git_output, "\n")
    let qf_item = {'filename': committed_file}
    call add(qf_list, qf_item)
  endfor
  " Fill quickfix list with them
  call setqflist(qf_list, '')
endfunction

" Show list of last-committed files
nnoremap <silent> <leader>g? :call CommittedFiles()<CR>:copen<CR>

" }}}

" Haskell Interrogation {{{

set completeopt+=longest

" Use buffer words as default tab completion
let g:SuperTabDefaultCompletionType = '<c-x><c-p>'

" But provide (neco-ghc) omnicompletion
if has("gui_running")
  imap <c-space> <c-r>=SuperTabAlternateCompletion("\<lt>c-x>\<lt>c-o>")<cr>
else " no gui
  if has("unix")
    inoremap <Nul> <c-r>=SuperTabAlternateCompletion("\<lt>c-x>\<lt>c-o>")<cr>
  endif
endif

" Show types in completion suggestions
let g:necoghc_enable_detailed_browse = 1

" qualified/unQualified import line
nmap <silent> <leader>hq :s/^import          /import qualified/<CR>:nohl<CR>
nmap <silent> <leader>hQ :s/^import qualified/import          /<CR>:nohl<CR>
vnoremap <silent> <leader>hq :s/^import          /import qualified/<CR>:nohl<CR>
vnoremap <silent> <leader>hQ :s/import qualified/^import          /<CR>:nohl<CR>

" Type of expression under cursor
nmap <silent> <leader>ht :GhcModType<CR>
" Insert type of expression under cursor
nmap <silent> <leader>hT :GhcModTypeInsert<CR>
" GHC errors and warnings
nmap <silent> <leader>hc :SyntasticCheck ghc_mod<CR>
" Haskell Lint
let g:syntastic_mode_map = { 'mode': 'active', 'passive_filetypes': ['haskell'] }
nmap <silent> <leader>hl :SyntasticCheck hlint<CR>

" Hoogle the word under the cursor
nnoremap <silent> <leader>hh :Hoogle<CR>

" Hoogle and prompt for input
nnoremap <leader>hH :Hoogle

" Hoogle for detailed documentation (e.g. "Functor")
nnoremap <silent> <leader>hi :HoogleInfo<CR>

" Hoogle for detailed documentation and prompt for input
nnoremap <leader>hI :HoogleInfo

" Hoogle, close the Hoogle window
nnoremap <silent> <leader>hz :HoogleClose<CR>

" }}}

" Conversion {{{

function! Pointfree()
  call setline('.', split(system('pointfree '.shellescape(join(getline(a:firstline, a:lastline), "\n"))), "\n"))
endfunction
vnoremap <silent> <leader>h. :call Pointfree()<CR>

function! Pointful()
  call setline('.', split(system('pointful '.shellescape(join(getline(a:firstline, a:lastline), "\n"))), "\n"))
endfunction
vnoremap <silent> <leader>h> :call Pointful()<CR>

" }}}

" Workspaces {{{
nnoremap <leader>w :ToggleWorkspace<CR>
let g:workspace_session_directory = $HOME . '/.vim/sessions/'
let g:workspace_session_disable_on_args = 1
let g:workspace_autosave = 0
" }}}

" Customization {{{

if filereadable(expand("~/.vimrc.local"))
  source ~/.vimrc.local
endif

" }}}

" Hanging indent soft-wrap
set breakindent
set breakindentopt=shift:2

" Nvim Compat
command! -nargs=1 R execute ":! " <q-args>

" PureScript
map <leader>pg :!$HOME/bin/purescript-tags.sh<CR>

" NeoMake
"let g:neomake_logfile = '/tmp/neomake.log'

" Elixir, NeoMake
augroup elixir
  autocmd!
  autocmd BufWritePost * Neomake
augroup END
"let g:alchemist_tag_disable = 1

" JS
"let g:neomake_javascript_enabled_makers = [] " 'flow'] " TODO: eslint
let g:neomake_javascript_enabled_makers = ['flow'] ", 'eslint']
"let g:neomake_open_list = 2 " an error dialog that pops up, preserving cursor location
let g:neomake_open_list = 0 " no dialog / loclist window.

" Flow
" Get the Flow type at the current cursor position.
function! Flow_get_type()
  let pos = line('.').' '.col('.')
  let path = ' --path '.fnameescape(expand('%'))
  let cmd = 'node_modules/.bin/flow type-at-pos '.pos.path
  let stdin = join(getline(1,'$'), "\n")

  let output = 'FlowType: '.system(cmd, stdin)
  let output = substitute(output, '\n$', '', '')
  echo output
endfunction
command! FlowType call Flow_get_type()
nnoremap <Leader>t :FlowType<CR>