Vim plugins

This page is about Vim plugins.

Overview

Find a plugin

Most plugins are found on vim.org or GitHub:

• https://github.com/vim-scripts?tab=repositories

A mirror of all plugins originally found on http://www.vim.org/scripts/ ;

• GitHub.

Install a plugin

The best is to use a plugin manager (see below). Otherwise,

• Unzip the plugin in ~/.vim directory (or plugin, autoload...)
• Generate the help tags with:

helptags ~/.vim/tags

Getting help

Most plugins come with local help files. Do :help local-additions to get a list of help files for locally installed plugins.

Plugin Managers

Here I list various plugin managers. My current favorite is vim-plug.

apt-vim

Fully-automated, Cross-platform Plugin Manager for Vim.

Pathogen

Plugin manager from Tim Pope.

VIM (vim-addon-manager)

VAM manage and install vim plugins (including their dependencies) in a sane way.

vim-plug

Plugin manager from junegunn, author of fzf, vim-easy-align.

Install

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

Update plugins on offline computer

To update plugins on a computer that has no internet access, the simplest solution is to clone all repositories in a folder accessible by the offline computer, and use the git URL rewriting feature to point to this folder instead.

Use the following script to sync the folder, vim-plug-mirror.sh:

#! /bin/bash

die()
{
    CODE=$1
    shift
    >&2 echo "ERROR -- $@"
    exit $CODE
}

usage()
{
    echo "Usage: $(basename $0) <mirror_dir>"
    die 1 "$*"
}

DIR=${1%%/}
echo $DIR

[ -n "$DIR" -a -d "$(dirname "$DIR")" ] || usage "Missing <mirror_dir>"

if ! [ -d "$DIR" ]; then
    echo "Creating $DIR"
    mkdir "$DIR" || die 1 "Cannot create '$DIR'"
fi

PLUGINS_DIR=$(find ~/.vim/plugged -name .git|sed -r 's_/\.git__')

for plugin_dir in $PLUGINS_DIR; do
    echo "Processing '$plugin_dir'"
    URL=$(git -C "$plugin_dir" remote get-url origin)
    plugin=$(echo $URL|sed -r 's_https://github.com/__; s_github\.com:__; s_\.git__')
    PLUGINDIR=$DIR/${plugin}.git
    PARENTDIR=$(dirname $PLUGINDIR)
    if [ -d "$PLUGINDIR" ]; then
        false && echo git -C "$PLUGINDIR" fetch --all
    else
        mkdir -p "$PARENTDIR" || die 1 "Cannot create '$PARENTDIR'"
        git clone --mirror $URL "$PLUGINDIR"
    fi
done

To use the script, simply give a folder path:

vim-plug-mirror.sh /smb/some/path

Then, on the offline machine:

sudo git config --system url./smb/some/path/.insteadOf https://github.com/

Interaction with $HOME version control

If we store our HOME files (dot-files) in git, we can't store the plugins anymore because they are fetched and stored locally as squashed git submodules. We can circumvent this by managing these plugins as git submodules.

First create .gitmodules:

[submodule "ack.vim"]
    path = .vim/plugged/ack.vim
    url = ./.vim/plugged/ack.vim
[submodule "auto-pairs"]
    path = .vim/plugged/auto-pairs
    url = ./.vim/plugged/auto-pairs
[submodule "a.vim"]
    path = .vim/plugged/a.vim
    url = ./.vim/plugged/a.vim

Then create the bare repositories:

git clone --bare /home/peetersm home.git
cd home.git/
mkdir -p .vim/plugged
cd .vim/plugged
for g in ~/.vim/plugged/*; do git clone --bare $g; done

Then, to clone the HOME repository:

git clone --recursive .../home.git

Finally we must update the tags file in vim. Start vim and run PlugInstall!. Ignore the error messages.

Troubleshooting

• Using short path may fail if plugin name has an extension. For instance:

" The following FAILS because of trailing .vim
Plug 'ctrlpvim/ctrlp.vim'
" Use the following instead.
Plug 'https://github.com/ctrlpvim/ctrlp.vim.git'

• Conditional plugin activation.

See the FAQ.

Installed plugins

Plugins I'm currently using.

A

a.vim : Alternate Files quickly (.c --> .h etc) (forked version, the original version)

ack.vim

	GitHub	ack.vim	Vim plugin for the Perl module / CLI script 'ack'

I fell back to this plugin because ag.vim is stalled. But we can still use ag as search engine.

My settings [1]:

if executable('ag')
  " Use ag over grep - See ag man page for option '--vimgrep'
  set grepprg=ag\ --vimgrep\ $*
  set grepformat=%f:%l:%c:%m

  " bind K to grep word under cursor
  nnoremap K :grep! "\b<C-R><C-W>\b"<CR>:cw<CR>
  let g:ackprg = 'ag --vimgrep'
  " Allow lowercase command 'ag' - see http://vim.wikia.com/wiki/Replace_a_builtin_command_using_cabbrev
  cnoreabbrev ag <c-r>=(getcmdtype()==':' && getcmdpos()==1 ? 'Ack' : 'ag')<CR>
endif

Auto-Pairs

vim.org	GitHub	auto-pairs	Vim plugin, insert or delete brackets, parens, quotes in pair
M-e )wrapme) M-n Jump to next closed pair

Tested on NeoVim: undoable and dot-repeatable (.) (and should be the same on vim 7.4.849+).

Works better than ClosePairs and similar.

More auto-close plugins or similar:

• https://github.com/cohama/lexima.vim

Tested on NeoVim: undo broken but dot-repeatable (.).

• delimitMate by Israel Chauca Fuentes, https://github.com/Raimondi/delimitMate [2]
• AutoClose by Karl Guertin, https://github.com/vim-scripts/AutoClose [3]
• AutoClose by Thiago Alves, https://github.com/vim-scripts/AutoClose--Alves [4]
• Best so far — Auto Pairs by Miao Jiang, https://github.com/jiangmiao/auto-pairs

Tested on NeoVim: undoable and dot-repeatable (.) (and should be the same on vim 7.4.849+).

• ClosePairs by Edoardo Vacchi, https://github.com/vim-scripts/ClosePairs [5]
• Smartinput by Kana Natsuno, https://github.com/kana/vim-smartinput

breaks undo / dot-repeat (tested on neovim). Nice support of triple apostrophe.

• Simple pairs by Orestis Markou, https://github.com/vim-scripts/simple-pairs [6]

Requires Python.

• vim-autoclose by Townk, https://github.com/Townk/vim-autoclose

Tested on NeoVim: undo broken but dot-repeatable (.).

More on auto-close plugins:

• Explanations on the issue by sharat78.
• All tips and plugins on wikia.com

More on the issue of dot-repeat (with list of plugins):

• http://stackoverflow.com/questions/883437/how-do-i-get-vim-to-automatically-put-ending-braces

AutoTag

AutoTag : Updates entries in a tags file automatically when saving

Cpp.vim

cpp.vim: General C++ Settings (no indentation for namespace...)

(disabled highlight of leading tabs, line length overruns, unit test header test + nice AlterColour function that computes new colour...)

cpsm

	GitHub	cpsm	A CtrlP matcher, specialized for paths.
C-p Ctrl-P file mode C-o Ctrl-P MRU mode

To install:

sudo apt install libboost-all-dev cmake python-dev libicu-dev
cd ~/.vim/plugged/cpsm
./install.sh

CScope

CScope (also mirrored on GitHub)

• Cscope page is available on SourceForge.
• See the tutorial here
• Cscope on Vim Wiki
• One can also use cscope and ctags together

ctrlp.vim

vim.org	GitHub	ctrlp.vim	Active fork of kien/ctrlp.vim—Fuzzy file, buffer, mru, tag, etc finder. home
^p Invoke CtrlP ^j ^k Navigate list ^z ^o Mark/unmark, open F5 Refresh cache ^t Open new tab :diffthis Compare marked files ^f ^b Cycle between modes ^v ^x Open new split ^d Switch filename/full ^n ^p Next/prev hist ^r Switch regexp mode ^y Create new file

Currently works best using ag (this and [7]) as file scanner and cpsm as match engine.

My settings:

" Set root directory
let g:ctrlp_working_path_mode = 'rwa'

" Enable filename search (instead of full path) - Ctrl-D to switch
let g:ctrlp_by_filename = 1
"
"  Use AG for look-up. See https://robots.thoughtbot.com/faster-grepping-in-vim
if executable('ag')
  " Use ag in CtrlP for listing files. Lightning fast and DOESN'T respect .gitignore
  let g:ctrlp_user_command = 'ag %s -U -l --nocolor -g ""'

  " ag is fast enough that CtrlP doesn't need to cache - BUT we are on a slow filesystem
  " let g:ctrlp_use_caching = 0
endif

DoxygenToolkit.vim

	GitHub	DoxygenToolkit.vim	Simplify Doxygen documentation in C, C++, Python
:Dox Fill doxygen for function declaration.

My configuration

" --- DoxygenToolkit --------------------------------------------------------------------------{{{
let g:DoxygenToolkit_briefTag_pre="@Synopsis  "
let g:DoxygenToolkit_paramTag_pre="@Param "
let g:DoxygenToolkit_returnTag="@Returns   "
let g:DoxygenToolkit_blockHeader="--------------------------------------------------------------------------"
let g:DoxygenToolkit_blockFooter="----------------------------------------------------------------------------"
let g:DoxygenToolkit_authorName="Michael Peeters"
" let g:DoxygenToolkit_licenseTag=""

Fugitive

vim.org	GitHub	fugitive.vim	A Git wrapper so awesome, it should be illegal

Add to .vimrc:

set diffopt+=vertical                       " Favor vertical split for vimdiff

Some commands

" Gdiff
:Gdiff                                      " View differences with index
:Gdiff HEAD                                 " View differences with HEAD
:Gdiff -                                    " View differences with HEAD
:Gdiff ^                                    " View differences with previous commit
:Gdiff ~3                                   " View differences with 3 commits ago

" Glog
:Glog                                       " Load previous file revision in quickfix. :cn / :cp for next/previous
:Glog -- %                                  " Load commits (i.e. diff) impacting current file.
:Glog -Sfindme --                           " Pickaxe string 'findme'

" Gedit
:Gedit                                      " Edit back current file

Typical workflow

• View history of changes on a file

:Glog                                       " Load previous file revision in quickfix
:cn                                         " next revision (or open quickfix window and <CR> to select)
:cp                                         " previous revision (or open quickfix window and <CR> to select)
:Gdiff                                      " View diff with version in work tree
:q                                          " Quit diff, and return to selected revision
:Gdiff ^                                    " View diff with previous version
:q
:Gedit                                      " Edit back original file

fzf.vim

	GitHub	fzf.vim	fzf :heart: vim
C-p Ctrl-P file mode C-o Ctrl-P MRU mode

Neovim

fzf.vim uses neovim terminal emulator. Use this mapping to have esc key leave fzf, but go to normal mode in other terminals [8]:

tnoremap <expr> <esc> &filetype == 'fzf' ? "\<esc>" : "\<c-\>\<c-n>"

IndentTab

vim.org	GitHub	IndentTab	Use tabs for indent at the beginning, spaces for alignment in the rest of a line

This plugin works better than Smart-Tabs (ctab.vim).

See also Indent with tabs & align with spaces.

Configuration

We must make sure that it is loaded before plugin SuperTab (so that the latter can record IndentTab maps for Tab).

Plug 'xeyownt/IndentTab' |                            " Use tabs for indent at the beginning, spaces for alignment in the rest of a line
    Plug 'ervandew/supertab'                          " Perform all your vim insert mode completions with Tab

" --- IndentTab -------------------------------------------------------------------------------{{{
let g:IndentTab = 1                                 " Enable the plugin
let g:IndentTab_IsSuperTab = 1                      " Enable integration with supertab
let g:IndentTab_scopes = 'indent'                   " Disable 'commentprefix' and 'string', which require ingo-library
" }}}

MatchIt

matchit.zip : extended % matching for HTML, LaTeX, and many other languages

Mcf-make-target

mcf-make-target: Persistent make target in Vim This plugin lets Vim to store the last arguments passed to make, and use that argument when make is invoked without arguments. For ease, define the following macro:

:nmap <F5> :wa<CR>:Make<CR>:cw<CR>             # Note the capital M to Make

To build a custom target:

:Make <targetname>           # first invocation. Store targetname for future use
<F5>                         # next

Repeat

Install repeat.vim : Use the repeat command (.) with supported plugins

SparkUp

Sparkup — A parser for a condensed HTML format Use ^e in edit mode to extend sparkup text, and ^n to go to next empty item. Some examples (more at Zen Coding:

div#page.section.main
div[title] 
a[title="Hello world" rel] 
td[colspan=2]
ul > li*5
li.item$$$*3
div#page>(div#header>ul#nav>li*4>a)+(div#page>(h1>span)+p*2)+div#footer
#content>.section
div#content>div.section
p>{Click }+a{here}+{ to continue}

Supertab

vim.org	GitHub	Supertab	Perform all your vim insert mode completions with Tab
Tab Complete, insert

Plug 'ervandew/supertab'                          " Perform all your vim insert mode completions with Tab

" --- SuperTab---------------------------------------------------------------------------------{{{
let g:SuperTabDefaultCompletionType    = '<C-n>'
let g:SuperTabCrMapping = 0
" }}}

Issues

• Tab does not work in vimwiki files

This is because Tab is mapped by vimwiki plugin to jump to next table cell. The best work-around is to use C-n / C-p to trigger YCM completion. Alternative we can disable table mapping [9]

let g:vimwiki_table_mappings = 0

Surround

surround.vim : Delete/change/add parentheses/quotes/XML-tags/much more with ease (github)

tComment

tComment : An extensible & universal comment plugin that also handles embedded filetypes

Ultisnips

	GitHub	ultisnips	UltiSnips - The ultimate snippet solution for Vim. Send pull requests to SirVer/ultisnips!
	GitHub	vim-snippets	vim-snipmate default snippets (Previously snipmate-snippets)
^J Expand snippet / go to next placeholder ^K Go to previous placeholder

Ultisnips is a snippet engine written in Python. Other snippet plugins:

• snipMate, inspired from TextMate.
• https://github.com/garbas/vim-snipmate (garbas' fork), http://github.com/msanders/snipmate.vim (original, stalled)
• Another engine, also very powerful but different syntax (not compatible with vim-snippets): https://github.com/drmingdrmer/xptemplate

Configuration

• We configure ultisnips to use ^J / ^K for expansion and next/previous, and leave Tab key for completion with plugin SuperTab (which will trigger YouCompleteMe as well).
• Another option is to use Tab for expansion (see these posts for instance).

" --- Ultisnips / vim-snippets-----------------------------------------------------------------{{{
" Use C-j/C-k for snippet expansion and next/previous.
" To use 'tab', see https://github.com/christoomey/dotfiles/blob/master/vim/rcplugins/youcompleteme-ultisnips-supertab
let g:UltiSnipsEditSplit = 'vertical'
let g:UltiSnipsExpandTrigger = '<C-j>'
let g:UltiSnipsJumpForwardTrigger = '<C-j>'
let g:UltiSnipsJumpBackwardTrigger = '<C-k>'

Snippets

Snippets must be installed separately. Some snippets from vim-snippets:

#### C ####

main  main()
inc   #include <...>
Inc   #include "..."
Def   #ifndef ... #define ... #endif
def   #define
ifdef #ifdef ... #endif
#if   #if ... #endif
once  #ifndef HEADER_H .... # define HEADER_H ... #endif (Header Include-Guard)
if    If (...) { ... } 
el    else { ... } 
t     ... ? ... : ... (tertiary conditional)
do    do ... while ( ... )
wh    while (...) { ... }
for   for (... = 0; ...; ...) { ... }
forr  for (... = ...; ...; ...) { ... }
fun   ... function(...) { ... }
fund  ... function(...;)
td    typedef
st    struct
tds   typedef struct
tde   typedef enum
pr    printf
fpr   fprintf
.     [ ... ]
un    unsigned

#### C++ ####

readfile  snippet for reading file
map       std::map<... , ...> map...
vector    std::vector<...> v...
ns        namespace ... { ... }
cl        class { public: ... private: };

LustyExplorer

vim.org	GitHub	LustyExplorer	Dynamic filesystem and buffer explore
More recent GitHub (merged with LustyJuggler)

FuzzyFinder

FuzzyFinder : buffer/file/command/tag/etc explorer with fuzzy matching

• Alternative, Command-T (inspired from TextMate)
• See also Super-Finder in Vim (using FuzzyFinder)
• After :set path=/path/to/project/**, one can do :find filename.ext (See [10], more details at [11])
• To find a file in a sub-directory, use the fuzzy query **/filename

vim-airline

	GitHub	vim-airline	lean & mean status/tabline for vim that's light as air
	GitHub	vim-airline-themes	A collection of themes for vim-airline

vim-airline-themes is optional, and here not needed since I use gruvbox for the theme.

" ----- Vim-airline ----------------------------------------------------------
let g:airline_theme= 'gruvbox'
let g:airline_section_c = '%F'
let g:airline_section_y = ''
let g:airline_section_error = ''
let g:airline_section_warning = ''
let g:airline_section_x = ''

vim-bufferline

	GitHub	vim-bufferline	Super simple vim plugin to show the list of buffers in the command bar

Beware that airline interferes with bufferline settings. My settings below.

" ----- Vim-bufferline -------------------------------------------------------

let g:bufferline_rotate = 1                " scrolling with fixed current buffer position
let g:bufferline_show_bufnr = 0            " Do not display buffer numbers
let g:bufferline_active_buffer_left = '['  " Separator used on the left side of current buffer
let g:bufferline_active_buffer_right = ']' " Separator used on the right side of current buffer

let g:airline#extensions#bufferline#overwrite_variables = 0

Vim BufStat

Vim BufStat

• MiniBufExplorer questions (closing a buffer, making it invisible, etc.) (use d in minibufexpl, :set hidden to navigate to other buf even if current modified)
• Can we remap :q to :bd only when 2 or more buffer opened?
• An alternative is buftabs: Minimalistic buffer tabs saving screen space (more at StackOverflow - An alternative to minibufexplorer (vim)?)
• StackOverflow - MiniBufExplorer and NERD_Tree closing buffers unexpected behavior: See tip165 - bclose + custom mapping below, :bd might just be good enough though...

" GRB: use fancy buffer closing that doesn't close the split
cnoremap <expr> bd (getcmdtype() == ':' ? 'Bclose' : 'bd')

Vim-easy-align

	GitHub	vim-easy-align	A Vim alignment plugin
gaip*= Auto-align around all occurences of = :%EasyAlign /;;/ Align on ;;. This allows using any delimiter.

Vim-easymotion

vim.org	GitHub	vim-easymotion	Vim motions on speed!
\\w \\f Horizontal move \\j \\k Vertical move

Example configuration

" <Leader>f{char} to move to {char}
map  <Leader>f <Plug>(easymotion-bd-f)
nmap <Leader>f <Plug>(easymotion-overwin-f)

" s{char}{char} to move to {char}{char}
nmap s <Plug>(easymotion-overwin-f2)

" Move to line
map <Leader>L <Plug>(easymotion-bd-jk)
nmap <Leader>L <Plug>(easymotion-overwin-line)

" Move to word
map  <Leader>w <Plug>(easymotion-bd-w)
nmap <Leader>w <Plug>(easymotion-overwin-w)

Vim-gitgutter

	GitHub	vim-gitgutter	A Vim plugin which shows a git diff in the gutter (sign column) and stages/undoes hunks

Vim-incsearch

vim.org	GitHub	incsearch.vim	Improved incremental searching for Vim
	GitHub	incsearch-easymotion.vim	Integration between incsearch and easymotion
Tab Move cursor to next match S-Tab Move cursor to previous match

See website for more features (including fuzzy search, etc.).

Integration with easy-motion

" You can use other keymappings like <C-l> instead of <CR> if you want to
" use these mappings as default search and somtimes want to move cursor with
" EasyMotion.
function! s:incsearch_config(...) abort
  return incsearch#util#deepextend(deepcopy({
  \   'modules': [incsearch#config#easymotion#module({'overwin': 1})],
  \   'keymap': {
  \     "\<CR>": '<Over>(easymotion)'
  \   },
  \   'is_expr': 0
  \ }), get(a:, 1, {}))
endfunction

noremap <silent><expr> /  incsearch#go(<SID>incsearch_config())
noremap <silent><expr> ?  incsearch#go(<SID>incsearch_config({'command': '?'}))
noremap <silent><expr> g/ incsearch#go(<SID>incsearch_config({'is_stay': 1}))

Vim-LaTeX

vim-latex (documentation See page vim-latex.

vim-mundo

	GitHub	vim-mundo	Vim undo tree visualizer https://simnalamburt.github.io/vim-mundo
F12 Open mundo

vim-mundo is a fork of plugin gundo (originally written by Steve Losh) that is up-to-date and works on neovim.

" --- Vim-mundo -------------------------------------------------------------------------------{{{
let g:mundo_verbose_graph = 0               " Create shorter graph
let g:mundo_inline_undo = 1                 " Show a small one line diff at each node
set undofile                                " Enable persistent undo so that undo history persists across vim sessions
set undodir=~/.vim/undo
nnoremap <F12> :MundoToggle<CR>
" }}}

VimWiki

vim.org	GitHub	vimwiki	Personal Wiki for Vim
S-CR Continue list gq Quote text block with {{{ ... }}}

To quote a text block with {{{ ... }}} in visual mode, add to ~/.vim/ftplugin/vimwiki_custom.vim:

" Quote a block of text with {{{ }}} in visual mode
:vmap gq DO {{{<CR><ESC>P

Troubleshooting

• Tab not working anymore on dev branch. This is because tab is already mapped by plugin SuperTab, and Vimwiki refuses to remap.

--- a/ftplugin/vimwiki.vim
+++ b/ftplugin/vimwiki.vim
@@ -532,13 +532,9 @@ endfunction
 
 " insert mode table mappings
 if str2nr(vimwiki#vars#get_global('key_mappings').table_mappings)
-  if maparg('<Tab>', 'i') ==# ''
   inoremap <expr><buffer> <Tab> vimwiki#tbl#kbd_tab()
-  endif
-  if maparg('<S-Tab>', 'i') ==# ''
   inoremap <expr><buffer> <S-Tab> vimwiki#tbl#kbd_shift_tab()
 endif
-endif

YouCompleteMe

	GitHub	YouCompleteMe	A code-completion engine for Vim http://valloric.github.io/YouCompleteMe/ Fast fuzzy auto-completion engine (suggest as you type). Semantic completion using clang. Instant diagnostics (errors and warnings reporting).
^n Next completion (also Tab using SuperTab plugin) ^p Previous completion (also S-Tab using SuperTab plugin)

Installation

cd .vim/plugged/YouCompleteMe
./install.py

Configuration (without semantic completion)

• We don't configure YCM to use Tab for completion but the usual vim's map ^n and ^p.
• Instead, we install SuperTab plugin, which will also trigger YCM completion with Tab and S-Tab (thanks Christoomey).

Plug 'Valloric/YouCompleteMe', { 'do': './install.py' } " A code-completion engine for Vim

" ...

" --- YouCompleteMe----------------------------------------------------------------------------{{{
let g:ycm_autoclose_preview_window_after_completion = 1 " Auto-close preview window on completion

let g:ycm_dont_warn_on_startup = 0
let g:ycm_complete_in_comments = 1
let g:ycm_complete_in_strings = 1
let g:ycm_collect_identifiers_from_comments_and_strings = 1

let g:ycm_filetype_blacklist = {}

let g:ycm_key_list_select_completion   = ['<C-n>', '<Down>']
let g:ycm_key_list_previous_completion = ['<C-p>', '<Up>']
" Bug workaround - avoid spurious scrolling on completion when typing '.'
let g:ycm_filetype_specific_completion_to_disable = {
      \ 'cpp': 1,
      \ 'gitcommit': 1
      \}
" }}}

Configuration (semantic completion)

Add the default compilation flags file .vim/.ycm_extra_conf.py (see manual for more details [12]):

def FlagsForFile( filename, **kwargs ):
  return {
    'flags': [ '-x', 'c++', '-std=c++14', '-Wall', '-Wextra', '-Werror' ],
  }

Then in .vimrc:

-Plug 'Valloric/YouCompleteMe', { 'do': './install.py' } " A code-completion engine for Vim
+Plug 'Valloric/YouCompleteMe', { 'do': './install.py  --clang-completer' } " A code-completion engine for Vim
-let g:ycm_filetype_specific_completion_to_disable = {
-      \ 'cpp': 1,
-      \ 'gitcommit': 1
-      \}
+let g:ycm_global_ycm_extra_conf = "~/.vim/.ycm_extra_conf.py"

Project-specific configuration

YCM can use project-specific compilation flags to report warnings / errors that are relevant to your project. YCM can either use a compilation database (such as BEAR, cmake, ninja...), or use manually defined flags. For the latter, just define a file .ycm_extra_conf.py in the root of your project:

def FlagsForFile( filename, **kwargs ):
  return {
    'flags': [ '-x', 'c++', '-std=c++14', '-Wall', '-Wextra', '-Werror', '-Isource', '-Iinclude', -'DTHIS_AND_THAT' ],
  }

Configuration - offline install

• When installing on a computer without internet access, transfer the file clang+llvm-5.0.0-linux-x86_64-ubuntu14.04.tar.xz from ~/.vim/plugged/YouCompleteMe/third_party/ycmd/clang_archives/ manually.

Plugins to try

Plugins I need to try or install some day.

• Other completion plugins, but probably not as good as YouCompleteMe (which also integrates nicely with Ultisnips and SuperTab)

vim.org		OmniCppComplete	C/C++ omni-completion with ctags database

vim.org		neocomplcache	Ultimate auto completion system for Vim

• c.vim : C/C++ IDE -- Write and run programs. Insert statements, idioms, comments etc.
• winmanager : A windows style IDE for Vim 6.0 (Referenced in TagList plugin help)
• bufexplorer.zip : Buffer Explorer / Browser
• project.tar.gz : Organize/Navigate projects of files (like IDE/buffer explorer)
• textobj-entire: Text objects for entire buffer (referenced from Practical Vim)
• LaTeX Box : Lightweight Toolbox for LaTeX
• unite.vim : Unite and create user interfaces (for more WOW factor, check this blog or the homepage)
• Plugin from OSCON 2013: "More Instantly Better Vim" - Damian Conway:
• autoswap.mac (manage automatically swap file — Mac only)
• vmath.mac (compute sums, averages, min and max)
• vis.vim (let : commands to act on visual blocks, not the full lines)
• visualdrags (allows moving / duplicate visual)
• closeb : Close complex brackets or tags
An extended version of closetag.vim. Press ^_ to automatically close current tag (HTML, XML, LaTeX...)
• Gist : vimscript for gist
• functionlist.vim : This plugin makes it easy to navigate between functions in a long file.
• ShowFunc.vim : Creates a list of all tags / functions from a window, all windows or buffers.
• taglist.vim : Source code browser (supports C/C++, java, perl, python, tcl, sql, php, etc)
• DeleteTrailingWhitespace : Delete unwanted whitespace at the end of lines
Currently using custom mapping / autocmd (see below).
• syntastic — Syntax checking hacks for vim
• diffchar.vim — Highlight the exact differences, based on characters and words

Plugins from Tim Pope:

• Tim Pope's commentary: comment stuff out (referenced from Practical Vim)

However tComment seems more complete, and works fine for me.

vim.org	GitHub	vim-rsi TRY_MY	rsi.vim: Readline style insertion

vim.org	GitHub	vim-abolish	abolish.vim: easily search for, substitute, and abbreviate multiple variants of a word

vim.org	GitHub	vim-obsession	obsession.vim: continuously updated session files

Some videos that illustrates those plugins:

• Top Vim Plugins (YouTube), showing Surround, SnipMate, TComment, MRU, FuzzyFinder, NerdTree, MatchIt
• Another list of nice plugins (MRU, SnipMate, VimExplorer)

vim.org	GitHub	unimpaired.vim	Pairs of handy bracket mappings
For interaction with plugin fugitive, and quickfix mappings [q, ]q, [Q, and ]Q.

vim.org	GitHub	ifdef-highlighting	#ifdef highlighting in c/c++/idl

	GitHub	VimFold4C	Vim folding ftplugin for C & C++ (and similar langages)

Interesting plugin, but does not handle well nested #ifdef it seems.

	GitHub	GoldenView.Vim	Always have a nice view for vim split windows! http://zhaocai.github.io/GoldenView.Vim/

Doxygen support

• https://github.com/vim-scripts/doxygen-support.vim (currently using DoxygenToolkit.vim).

Uninstalled plugins

Plugins I'm no longer using.

Align

vim.org	GitHub	Align	Help folks to align text, eqns, declarations, tables, etc
see examples.

Let's give vim-easy-align a try instead.

AutoClose

vim.org	GitHub	AutoClose	Inserts matching bracket, paren, brace or quote

Don't like it much because inserting the closing pair will jump out of nested pair, which is annoying when one try to simply insert a closing brace (but a solution is to use the Surround plugin to surround some selected text with braces).

Calendar

calendar.vim - A calendar application for Vim

• :Calendar to launch. < and > to cycle through views, E and T to view Event list or Task list.
• :Calendar 2001 1 1 to focus a specific date.

My settings in .vimrc:

" ----- Vim-Calendar ---------------------------------------------------------
let g:calendar_week_number=1
let g:calendar_first_day='monday'

ClosePairs

vim.org	GitHub	ClosePairs	Auto closes pairs of characters

simpler than AutoClose, and can also delete pair of braces at once with <BS>. However breaks undo and not dot-repeatable.

Below is a patch to push down the closing brace when typing { twice (inspired from AutoClose plugin).

~/.vim/plugin/closepairs.vim.diff (<file name="closepairs.vim.diff" tag="source">download</file>)

--- a/.vim/plugin/closepairs.vim
+++ b/.vim/plugin/closepairs.vim
@@ -10,7 +10,7 @@


 inoremap ( ()<left>
-inoremap { {}<left>
+inoremap <expr> { <SID>openpair('{','}')
 inoremap [ []<left>

 vnoremap <leader>" "zdi"<c-r>z"
@@ -44,6 +44,16 @@ function! s:delpair()
                return "\<bs>"
 endf

+function! s:openpair(left,right)
+       let l:col = col('.')
+       let l:lchr = getline('.')[l:col-2]
+       let l:rchr = getline('.')[l:col-1]
+    if a:left == l:lchr && a:right == l:rchr
+        return "\<esc>a\<CR>;\<CR>".a:right."\<esc>\"_xk$\"_xa"
+    endif
+    return a:left.a:right."\<left>"
+endf
+
 function! s:escapepair(right)

Conque Shell

vim.org	GitHub	Conque Shell	Run interactive commands inside a Vim buffer.

I'm using mostly NeoVim now, and neovim native command :term offers a much better alternative.

DiffChanges

diffchanges.vim : Show changes made to current buffer since the last save

• Never used. Functionality quite limited (only compared with last save). And if file is stored in Git, plugin fugitive is a much better alternative.

EasyTags

easytags.vim : Automated tag file generation and syntax highlighting of tags in Vim

• Replaced by AutoTag — syntax highlighting of tags is limited to c files; moreover AutoTag has a clever way to look for the tags file in project hierarchy.

Git-file

git:file.vim : open any version of a file in git For instance, to open file filename.c at commit HEAD~4:

vim HEAD~4:./filename.c

• Never used. Similar functionality available in plugin fugitive.

Hexman

vim.org	GitHub	Hexman	Simpler Hex viewing and editing

Uninstalled because it contains the sign of the devil... Well, no, in fact because I don't use it much and standard mappings interfere with vim-gitgutter.

LaTeX Text Formatter

Latex Text Formatter : This scripts makes it easier to format latex text

• Does not work well (line too short, line merge too aggressive)

LustyJuggler

vim.org	GitHub	LustyJuggler	Switch very quickly among your active buffers
More recent GitHub (merged with LustyExplorer

Removed because I don't use it. LustyExplorer, NERDTree and FuzzyFinder are much better alternatives.

MiniBufExpl

minibufexpl.vim : Elegant buffer explorer - takes very little screen space

• 1st attempt: No real tab support. Seems to interfere with trinity plugin. Interesting key bindings inside though. To reassess...
• 2nd attempt: Don't care about tabs, the idea is to fully replace tabs with buffers since most plugins interface better with buffers. Disabled

trinity plugin.

• Closing a buffer: Use d in minibufexpl window to close a buffer, or :bd[elete] seems to work most of the time.
• Uninstalled because found better alternative (bufstat)

• Someone is working on improving minibufexpl (v6.4)

MRU

mru.vim : Plugin to manage Most Recently Used (MRU) files

• Never used. And same functionality is available in Ctrl-P plugin anyway.

~/.vim/plugin/mru.vim.diff (<file name="mru.vim.diff" tag="source">download</file>)

--- mru-old.vim	2010-06-29 00:45:59.000000000 +0200
+++ mru.vim	2010-07-22 14:14:19.000000000 +0200
@@ -657,7 +657,12 @@
                 let wcmd = '+buffer' . bufnum
             endif
 
-            exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
+            " MIP PATCH BEGIN - :botright conflicts with TagList + QuickFix windows
+            " if I have TagList + QuickFix window opened, calling :MRU multiple times makes the QuickFix window to grow
+            " endlessly
+            " exe 'silent! botright ' . g:MRU_Window_Height . 'split ' . wcmd
+            exe 'silent! ' . g:MRU_Window_Height . 'split ' . wcmd
+            " MIP PATCH END
         endif
     endif

Trinity.vim

trinity.vim : Build the trinity of srcexpl, taglist, NERD_tree to be a good IDE

• Source Explorer (srcexpl.vim) : A Source code Explorer based on tags works like context window in Source Insight
• taglist.vim : Source code browser (supports C/C++, java, perl, python, tcl, sql, php, etc)
• The NERD tree : A tree explorer plugin for navigating the filesystem

~/.vim/plugin/trinity.vim.diff (<file name="trinity.vim.diff" tag="source">download</file>)

--- trinity.vim	2009-12-22 19:50:06.000000000 +0100
+++ trinity-new.vim	2010-07-06 01:24:28.000000000 +0200
@@ -90,7 +90,7 @@
     " Set the window width
     let g:Tlist_WinWidth = 24
     " Sort by the order
-    let g:Tlist_Sort_Type = "order"
+    let g:Tlist_Sort_Type = "name"
     " Do not display the help info
     let g:Tlist_Compact_Format = 1
     " If you are the last, kill yourself
@@ -100,7 +100,7 @@
     " Do not show folding tree
     let g:Tlist_Enable_Fold_Column = 0
     " Always display one file tags
-    let g:Tlist_Show_One_File = 1
+    let g:Tlist_Show_One_File = 0
 
 endfunction " }}}

~/.vim/plugin/taglist.vim.diff (<file name="taglist.vim.diff" tag="source">download</file>)

--- taglist.vim	2007-09-21 18:11:20.000000000 +0200
+++ taglist-new.vim	2010-07-06 01:08:11.000000000 +0200
@@ -3207,14 +3207,7 @@
             if a:win_ctrl == 'newwin'
                 split
             endif
+		    " 20100706 - MIP PATCH BEGIN - USE badd / buffer! so that we can
+		    " switch files even when current buffer changes are not written ----
+		    if !bufexists(a:filename)
+		        exe "badd " . escape(a:filename, ' ')
+		    endif
+		    exe "buffer! " . escape(a:filename, ' ')
+		    " exe "edit " . escape(a:filename, ' ')
+		    " 20100706 - MIP PATCH END -----
-            exe "edit " . escape(a:filename, ' ')
         else
             " Open a new window
             if g:Tlist_Use_Horiz_Window

~/.vim/plugin/taglist.vim.diff (<file name="taglist.vim.diff" tag="source">download</file>)

--- taglist.vim	2011-06-27 00:32:33.000000000 +0200
+++ taglist-new.vim	2011-06-27 00:37:23.000000000 +0200
@@ -1552,6 +1552,8 @@
                 \ :call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
     nnoremap <buffer> <silent> o
                 \ :call <SID>Tlist_Window_Jump_To_Tag('newwin')<CR>
+    nnoremap <buffer> <silent> O
+                \ :call <SID>Tlist_Window_Jump_To_Tag('newwinv')<CR>
     nnoremap <buffer> <silent> p
                 \ :call <SID>Tlist_Window_Jump_To_Tag('preview')<CR>
     nnoremap <buffer> <silent> P
@@ -1592,6 +1594,8 @@
                 \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
     inoremap <buffer> <silent> o
                 \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('newwin')<CR>
+    inoremap <buffer> <silent> O
+                \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('newwinv')<CR>
     inoremap <buffer> <silent> p
                 \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('preview')<CR>
     inoremap <buffer> <silent> P
@@ -3206,6 +3210,10 @@
             " the existing window into two.
             if a:win_ctrl == 'newwin'
                 split
+            " 20110627 - MIP PATCH BEGIN - Allow vertical split -----
+            elseif a:win_ctrl == 'newwinv'
+                vsplit
+            " 20110627 - MIP PATCH END -----
             endif
 			" 20100706 - MIP PATCH BEGIN - USE badd / buffer! so that we can
 			" switch files even when current buffer changes are not written ----
@@ -3265,6 +3273,10 @@
         " existing window into two.
         if a:win_ctrl == 'newwin'
             split
+        " 20110627 - MIP PATCH BEGIN - Allow vertical split -----
+        elseif a:win_ctrl == 'newwinv'
+                vsplit
+        " 20110627 - MIP PATCH END -----
         endif
     endif
     endif
@@ -3313,6 +3325,7 @@
 " Jump to the location of the current tag
 " win_ctrl == useopen - Reuse the existing file window
 " win_ctrl == newwin - Open a new window
+" win_ctrl == newwinv - Open a new window (vertical)
 " win_ctrl == preview - Preview the tag
 " win_ctrl == prevwin - Open in previous window
 " win_ctrl == newtab - Open in new tab