

Plugins you should put in your vimrc - vesln
http://www.vimninjas.com/2012/09/03/5-plugins-you-should-put-in-your-vimrc/

======
begriffs
I recently "declared vim bankruptcy" and rebuilt my vimrc from scratch. I want
a full-featured vim, but I want to keep it responsive.

There are many fancy presets out there <https://github.com/skwp/dotfiles>
<https://github.com/carlhuda/janus> <https://github.com/spf13/spf13-vim>
<https://github.com/vgod/vimrc> but they freak me out. They turn vim into a
singing, dancing, syntax/spell checking, indexing, buffer Whack-a-mole. My
philosophy is that vim shouldn't do anything behind your back, but it should
do great things if you ask.

    
    
      * Jumping to definitions
      * Finding all uses of a symbol in a repo
      * Running things
        + A test
        + Code in a repl
      * Git blame, diff
      * Summarizing methods in open file
      * Navigating my (rails) app
    

When putting this together, I found Vundle to be the easiest package manager.
Just specify any desired vim plugin github repos in your vimrc and let the
:BundleInstall, :BundleClean etc commands do the rest.

I used the standard plugins for most of the stated objectives, but there are
places where I found some tricks. The coolest trick is running external
programs without locking vim. You can send commands and selections to a tmux
terminal using Vimux: <https://github.com/benmills/vimux> After wrangling with
running vim under tmux, I discovered that the vimux plugin works in MacVim too
when tmux is running alongside.

The thing I run most often is tests. In Rubyland people advise using Guard,
which runs tests automatically when test files change. However this goes
against my "don't do things behind my back" philosophy. Vim-turbux is more my
taste. It extends vimux to run cucumber and rspec tests with the press of a
key: <https://github.com/jgdavey/vim-turbux>

The next area where most megadotfile presets are lacking is finding the uses
of code. Finding code definition is pretty well handled by exuberant-ctags and
vim-rails, but finding code uses is trickier. The cscope utility does this,
but its language support is limited from what I could tell. Another contender
is GNU global. Its setup is...interesting: [http://simple-and-
basic.com/2008/10/using-rtags-ang-gtags-fo...](http://simple-and-
basic.com/2008/10/using-rtags-ang-gtags-for-coding-ruby.html) I couldn't get
it working and the GTAGS files it generates cluttered my repos. I cheated and
just mapped a key to do :Ggrep (git-fugitive) on the current word. While
cscope or global would give the finest results, a massive grep comes close.
Let me know, anyone, if you've gotten the tagging systems working better.

My work in progress is here: <https://github.com/begriffs/dotfiles> I'd
appreciate any criticism; I have lots to learn.

------
qznc
I prefer CtrlP to CommandT, since it does not requires external programs.

<https://github.com/kien/ctrlp.vim>

~~~
ConstantineXVI
As others have said CtrlP is slower; but not having the Ruby dependency makes
it _far_ less of a headache to install on Windows, should you ever find
yourself on such a machine.

~~~
mun2mun
Installing command-t is fairly easy on windows. Just compile as instructed
with latest ruby 1.9 + devkit and replace gvim.exe with the one specified in
this page <https://wincent.com/comments/6544>.

~~~
tomku
That's a perfect example of something that is both easy AND a headache. It's
not certainly difficult to do, but I don't want to be replacing my gvim
executable with one provided by an anonymous forum user just to make one
script work. Ignoring the potential security issue, what happens when I want
to upgrade vim, or run another script that's similarly "easy" to install on
Windows?

I can't speak for other vim users, but I haven't had a lot of luck with distro
versions of vim and Ruby/Python extension scripts on Linux either. After
fighting with it for a while, I ended up just declaring my .vimrc to be a
VimScript-only zone. It sucks losing Gundo and Command-T and a couple other
great plugins, but it's done wonders for my sanity, and everything works well
on Windows as a bonus.

~~~
mun2mun
Well the forum is not actually an anonymous forum, the site owner is creator
of command-t plugin. When I encountered crash after installing command-t after
upgrading to 7.3 almost 1.5 years ago the first google search led me to that
page (now first result is this page [http://chrislaco.com/blog/gettimg-
command-t-working-on-windo...](http://chrislaco.com/blog/gettimg-command-t-
working-on-windows/), even better with instruction).

I also had no problem installing it in Ubuntu/Mint. Just removed vanilla vim
and installed vim-gtk and then compiled command-t.

Command-t is actually my only non-vimscript plugin in my plugin list, and it
is rightfully so :). I tried to cope with CtrlP, but it feels too slow for me
for large collection of files. Also its fuzzy matching is not on par with
command-t. I have actually no problem to take this _little_ hassle to install
command-t for performance consideration :).

------
StavrosK
Any vim plugin post that doesn't contain Vundle is incomplete, in my opinion.
How else are you going to manage all these plugins?

<https://github.com/gmarik/vundle>

~~~
5h
This, a hundred times over, after using vim for 4 years full time (e.g. pretty
much 8 hours a day, and who knows how long before that intermittently) I
finally took setup vundle, it was so worth all of the 600 or so seconds it
took to get working.

~~~
StavrosK
Ten minutes is overstating it, even. I just downloaded the thing, pasted the
other thing into my .vimrc, done.

~~~
5h
I had to weed out all the crap that I had accumulated in ~/.vim/ over the
years :)

------
intractable
Every time an article like this comes up, snipMate seems to be mentioned. This
particular author even pointed to the old repository which appears
unmaintained and has not had a check-in for two years.

Where's the love for UltiSnips? [1]

UltiSnips is actively maintained and well documented, not to mention
supporting many more features, such as Python interpolation. More info at [2].

[1] <https://github.com/SirVer/ultisnips>

[2] <http://fueledbylemons.com/blog/2011/07/27/why-ultisnips/>

~~~
gaving
+1 for ultisnips, definitely the superior option when it comes to templating.

~~~
don_draper
I just installed it. It's pretty good. The docs aren't great though. I hate
sitting through screencasts.

------
gnosis
My favorites:

    
    
      * pathogen [1]
      * PreciseJump [2]
      * MRU [3]
      * scratch [4]
      * xptemplate [5]
      * renumber [6]
    

[1] - <http://www.vim.org/scripts/script.php?script_id=2332>

[2] - <http://www.vim.org/scripts/script.php?script_id=3437>

[3] - <http://www.vim.org/scripts/script.php?script_id=521>

[4] - <http://www.vim.org/script.php?script_id=389>

[5] - <http://www.vim.org/scripts/script.php?script_id=2611>

[6] - <http://www.vim.org/scripts/script.php?script_id=189>

~~~
wahnfrieden
Use vundle instead of pathogen - it installs the plugins for you, so managing
them in source control is much easier. Lines in a vimrc are much less of a
headache than git submodules etc.

~~~
karategeek6
> Lines in a vimrc are much less of a headache than git submodules etc.

I disagree. This may be true if you don't understand git submodules, but git
submodules are not hard to understand with just a little effort. Once
understood, git submodules are very easy to work with.

Also, this may be just a personal quirk, but I'm not very fond of managing vim
from within vim. It would bug the living daylights out of me to load vim just
to update my plugins. I'm probably the only one who feels that way, though.

------
tux1968
Have to agree with the author about his picks. Excluding a couple programming-
language specific plugins the only other ones that i'd include on a longer
list would be:

EasyGrep - A nice quick way to search for arbitrary text when ctags/cscope
doesn't have the answer. <https://github.com/vim-scripts/EasyGrep>

QuickFixSigns - Show marks associated with each line in a buffer. Also shows
lines that have been changed from what has been committed to Git.
<https://github.com/vim-scripts/quickfixsigns>

Would be interested to know what others have to say about SuperTab since i'm
thinking of giving it a try. <https://github.com/ervandew/supertab>

~~~
goatslacker
Definitely give supertab a shot. It's recently become one of my favourite
plugins and now I'm tabbing religiously

------
d0m
I clicked the article thinking "Please, don't say Surround, Cmd-T, snipmate or
Buffer Explorer".. These are amongst the most popular plugins for Vim and
every week there are blogs saying exactly the same thing.

Note: I have nothing against this blog in particular.. but please, upvoters,
try to upvote new stuff.

~~~
intractable
I agree.

But, I must say: no matter how repetitive these articles, I pick up something
new in the HN comments every single time.

------
thurn
Emacs versions to check out:

Surround: wrap-region (<https://github.com/rejeep/wrap-region>)

Command-T: ido-mode with ido-find-file

snipMate: YASnippet

Syntastic: flymake

Buffer Explorer: ibuffer

~~~
naglfar
I actually tried really hard to get ido-mode to recursively search files under
the current directory, but I was never successful.

Is there some really easy modification I have overlooked? Because that is one
of the major advantages CtrlP or Command-T have - and trying to use
<https://github.com/emacs-helm/helm> with
<https://github.com/bbatsov/projectile> turned out to be by far too slow.

------
Hates_
I've moved to ctrlp over Command-T as it's pure Vimscript. Feels even faster
than Command-T to me:

<https://github.com/kien/ctrlp.vim>

~~~
derwiki
How many files is the project you try it on? CommandT is faster for me, but
only noticeably on large projects.

------
przemoc
Before snipMate came in 2009, snippetsEmu was already out there, since 2005!
It's true though, that snipMate may seem more robust.

Check also pkrumins' Vim Plugins You Should Know About:

<http://www.catonmat.net/blog/vim-plugins-surround-vim/>
<http://www.catonmat.net/blog/vim-plugins-repeat-vim/>
<http://www.catonmat.net/blog/vim-plugins-matchit-vim/>
<http://www.catonmat.net/blog/vim-plugins-snipmate-vim/>
<http://www.catonmat.net/blog/vim-plugins-a-vim/>
<http://www.catonmat.net/blog/vim-plugins-nerdtree-vim/>
<http://www.catonmat.net/blog/vim-plugins-ragtag-allml-vim/>

------
johnkchow
One of my favorite plugins that hasn't been mentioned so far is vim-powerline
<https://github.com/Lokaltog/vim-powerline>. It makes Vim have a really
polished look to it, and more important: tells you which Git branch you're
currently in.

~~~
tomjakubowski
For me, vim-powerline gives a much stronger visual indicator of the current
mode. Changing the color of the whole statusline really stands out.

------
johncoltrane
Wow, another post with the exact same plugins as all the other posts.

These are all the 13 plugins currently sitting in my bundle directory:

* AutoComplPop

Provides auto completion. I like/need auto completion less and less, these
days, so this one is on its way out. I tend to deactivate it and use my old
custom mappings for omni completion instead.

The no plugin way:

    
    
        inoremap ,, <C-x><C-o>
    

* Commentary

Toggles comments.

The no plugin way:

    
    
        0i//
        :s+^//++
    

* CtrlP

Super sleek fuzzy file/buffer/tag navigation. I love it.

The no plugin way:

    
    
        :e filename
        :sp *na<tab>
        :vs **/fi<tab>
        :sb *na<tab>
        nnoremap <leader>ls :ls<CR>:sb<Space>
        etc.
    

* DelimitMate

Automatically adds the second "')]}.

The no plugin way:

    
    
        inoremap { {}<left>
    

* EasyGrep

Handy cross-files/buffers search/replace. More convenient than the default
mechanism.

The no plugin way:

    
    
        :vimgrep <cword> *.js | copen
    

* InsertImg (customized)

Inserts an <img> tag with the correct width and height.

* SnipMate

I use the old one as it does everything I need without any problem.

The no plugin way:

    
    
        :help abbreviations
    

* Sparkup

Uses CSS syntax to quickly create large HTML layouts:

    
    
        div.aclass*5 > p{lorem ipsum} + img.anotherclass[src=/images/img.png]
    

* Surround

See the article. This one is almost a good reason in of itself to switch to
Vim.

* Syntastic

Syntax checking of many languages on the fly. Super handy.

* Tabular

Because I like my code neatly aligned.

* Visincr

I actually don't use this one much but it helps a lot when I need to write
lists of numbers/letters.

* Word-Column

The new kid on the block. Provides a text-object for columns.

and the 14th, currently testing:

* EasyMotion

------
ninjay
Thank you for showing how to use the plugins, most of these articles don't.

I looked at the rest of the site, bookmarked!

Can I make an article suggestion though? I'm a new(ish) vim user that is
always on different systems. I need a way to quickly install/remove my vim
settings and plugins. A tutorial how to do this would be awesome.

Take for granted vim and git are already installed, my ideal workflow would be
something like this:

git clone git://blah.blah/my_settings.git ./my_settings/install.sh

Now I can run vim and my whole environment will be ready. If I make any
changes I should be able to run git push to update the repository. Then I
could run remove.sh to clean everything up.

Is there a system like this out there already?

~~~
StavrosK
As I posted above, there's Vundle:

<https://github.com/gmarik/vundle>

You just copy your .vimrc over and Vundle installs everything.

~~~
ninjay
Vundle seems like it only takes care of the plugins. I'm looking for a vim
install system, like Python's setup.py.

~~~
intractable
The rage these days seems to be to keep your own dotfiles repo, complete with
some kind of install mechanism.

My own is here [1] but it covers my whole homedir, not just VIM. I use Rake
tasks (originally inspired by @holman, I believe) for install / update /
clean.

There is a bootstrapping problem when using Vundle with many plugins [2]. The
only way to have your Vundles install cleanly the first time is to split up
.vimrc into two separate files, which is what I have done.

[1] <https://github.com/anthonywilson/dotfiles>

[2] [http://www.gmarik.info/blog/2011/05/17/chicken-or-egg-
dilemm...](http://www.gmarik.info/blog/2011/05/17/chicken-or-egg-dilemma)

------
keithpeter
<https://github.com/davidbeckingsale/writegood.vim>

The Writegood scripts can be handy if you write non-fiction prose in Vim.

A strange synchronicity: I came across the page at

[http://matt.might.net/articles/shell-scripts-for-passive-
voi...](http://matt.might.net/articles/shell-scripts-for-passive-voice-weasel-
words-duplicates/)

and duly copy/pasted the bash scripts and ran them over some text files. Quite
useful. Then I saw this thread and wondered if anyone had done a vim plug in
for them. And davidbeckingsale has.

------
petepete
I already happen to have these in my setup; if you're a git user I highly
recommend fugitive.vim too.

<https://github.com/tpope/vim-fugitive>

~~~
matthiasv
I tried to incorporate it in my workflow several times, but usually I end up
<C-Z>ing the Vim process and commit, branch etc. via the command line. I
understand that Fugitive _might_ help resolving merge conflicts, but this is
really just a small percentage of my daily Git workflow.

Maybe, there is some deeper sense in it that I haven't grasped yet?

~~~
mjhoy
That's what I do, too. I keep it around for :Gblame.

------
equalsione
OTF isn't mentioned often but is extremely useful if you have to work with log
files on a regular basis.

It allows you to define up to 10 search terms and highlights them in different
colors, making it easy to see patterns of output in logs.

It doesn't sound that amazing at first but is worth trying if you herd log
files for a living.

<http://vim.sourceforge.net/scripts/script.php?script_id=634>

------
tsahyt
Among the things I personally couldn't do without these days snipMate, which
is mentioned in the article. Then there's clang_complete which made me very
happy. Finally a _compiler-based_ auto-completion for C in vim. Last but not
least there's fugitive. That's really most of what I need since vim already
provides a lot of useful features by itself.

------
imalolz
I agree to these five, and add:

* matchit - extends % functionality to support HTML/XML tags and also functions, blocks, conditionals in many languages.

* Supertab - tab completion done right.

* Tagbar or Taglist - code tree browser.

------
jeromche
Nice to see another VIM article on Hacker News.

------
CeRRuTiTo
Very useful, thanks. These days I changed double quotes to single so many
times and this comes just in the right moment!

------
don_draper
installing snipmate through pathogen is still a dark art

~~~
johncoltrane
1\. Download

2\. Unzip in ~/.vim/bundle

3\. Done

How is that "dark art"?

------
karmicthreat
This is perfect since I'm just starting with vim.

~~~
davidarkemp2
In my experience, it's better to spend a long time playing with Vim, and then
look at plugins. There's a lot that Vim does out of the box without any
additional tools, and spending time learning to use (some) of it without
trying to make it more like another editor is the only way you're going to get
better at it. Learn about buffers and how to manage them before using
BufExplorer. Learn the (many) movement keys, and insertion, append, replace,
substitue, change, options before you use Surround.

It may sound odd, but learn to use the tool by itself before you try and
plugin anything else, otherwise you'll just get lost.

~~~
icambron
I disagree. As someone who started using Vim recently, the issue wasn't
learning modes/key sequences as it was just reaching feature parity with my
previous editor (note that doesn't mean "acts like my previous editor", just
"is at least as capable as my previous editor"). If I can't open files really
quickly, I feel lost and upset, so I took care of that very early in the
learning process by setting up CtrlP. Same with some other plugins.

More generally, to me, the features that happen ship with Vim aren't special.
I want the best editor for me, which might require features the builders of
Vim didn't want to include. Vanilla is just another flavor.

~~~
johncoltrane
That's why you need to learn Vim without plugins. Vim can "open files really
quickly":

    
    
        :e *ba<Tab>
        :vs ../**/fo<Tab>
    

I love CtrlP but you can go a long way without any plugins. It just takes some
time and effort.

------
modarts
So.. we like Vim now?

