Testing Vim plugins is usually a non-trivial task. Many people just don’t do it because they find it either too painful or simply don’t know how to do it efficiently. However, if you like Ruby, there is a great tool that will help you write beautiful, easy to read, end-to-end tests for your Vim projects.

Introducing Vimrunner

Vimmrunner, written by Andrew Radev, is a project that spawns Vim instances using Vim’s client/server functionality and allows you to control them programmatically. It’s written in Ruby and you can find its docs on rubydoc.info. The gem has very intuitive API, and if you are already familiar with the tools in the Ruby ecosystem, you will be up and running in no time. In the next sections I’ll walk you trough writing a simple spec, in order to showcase some of Vimrunner’s abilities.

Getting started

We’ll be testing a simple Vim plugin that replaces “vim” with “Vim” in markdown files:

1

au FileType markdown autocmd BufWritePre <buffer> :%s/vim/Vim/g

To use Vimrunner, you need to install Ruby and your Vim must be compiled with the +clientserver option. For more info, check out Vimrunner’s requirements

The setup

Let’s start by creating a simple structure for our project:

1
2
3

$ mkdir plugin spec
$ touch spec/spec_helper.rb spec/plugin_spec.rb
$ touch Gemfile plugin/sws.vim

The test runner we’ll be using is RSpec. However, you could use minitest or any other runner that fits your needs. Also, bundler will be required to manage our dependencies.

Gemfile:

1
2
3
4

source 'https://rubygems.org'

gem 'rspec'
gem 'vimrunner', '0.3.0'

plugin/sws.vim:

1

au FileType markdown autocmd BufWritePre <buffer> :%s/vim/Vim/g

spec/spec_helper.rb:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

require 'vimrunner'
require 'vimrunner/rspec'

Vimrunner::RSpec.configure do |config|
  # Reuse the Vim server
  config.reuse_server = true

  plugin_path = File.expand_path('.')

  config.start_vim do
    # Use GVim
    vim = Vimrunner.start_gvim

    # Tell Vimrunner to include our plugin
    vim.add_plugin(plugin_path, 'plugin/sws.vim')

    vim
  end
end

Now run bundle install to install our dependencies.

The spec

What we would like to do is edit a markdown file, insert some text that contains “vim”, then save and assert that “vim” has been replaced with “Vim”. Here is how you could accomplish this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

require 'spec_helper'

describe 'sws' do
  it 'replaces vim with Vim in markdown files' do
    # Edit temporary markdown file
    vim.edit!('test.markdown')

    # Insert some text
    vim.insert('vim is awesome. vim vim vim')

    # Save the file
    vim.write

    # Make sure vim has been replaced with Vim
    vim.echo('getline(".")').should eq 'Vim is awesome. Vim Vim Vim'
  end
end

Now, you can run the tests by invoking RSpec:

1
2
3
4
5
6

$ rspec

.

Finished in 0.64155 seconds
1 example, 0 failures

Let’s write an additional spec that ensures our plugin is being activated only when editing makrdown files:

1
2
3
4
5
6

  it "performs substitutions only in markdown files" do
    vim.edit!('test.rb')
    vim.insert('vim.edit! "foo"')
    vim.write
    vim.echo('getline(".")').should eq 'vim.edit! "foo"'
  end

If you run the specs again, you will see that we have 2 passing examples and 0 failures.

That’s it! Vimrunner makes controlling Vim instances a dead simple task. We wrote our first test in no time, and we have the confidence that our plugin is actually working as desired.

The entire source code is available on GitHub - vesln/vim-sws.

Conclusion

In this post we covered how to spawn a Vim instance and control it programmatically in order verify that our plugin works correctly. However, there are many other situations in which you would find Vimrunner useful, testing is just one of them. I encourage you to take a look at the project and spend some time playing with it. I’m sure you’ll come up with great ideas. Cheers!

This is a guest post from Per Thulin. Many know him from having worked at the crowdfunding startup Flattr and being co-founder of the online music service Youtify.

Twitter: @pthulin GitHub: @pthulin

Hi, my name is Per Thulin and I am happy to be writing to a crowd full of handsome Vim users - my favorite kind of people!

I’ve been using Vim for longer than I can remember, but have started to feel jealous of my colleagues with their shiny new editors such as SublimeText and TextMate. Their syntax highlighting is so fast and they have tools for navigating file structures that just seem superior to anything that can be accomplished with Vim and it’s plugins.

So I’ve started a new project, an HTML5 remake of my good old Vim editor, using modern technologies such as HTML5. It’s called HappyEdit and is 100% open source and based on the Ace project worked on by Cloud9, Mozilla and others.

I’ve got an initial version ready that already feels wonderful to use and that has replaced MacVim as my main text editor.

Implemented features in HappyEdit:

• Vim like INSERT/COMMAND/NORMAL modes, keybindings and search.
• Beautiful command line with autocompletions for files and commands.
• Tabbed interface.
• Minimalistic window border design.
• Blazingly fast syntax highlighting for 40+ languages.
• CommandT-like way of opening files.
• A remote mode, so that you can work on files that are on another computer.

Upcoming features:

• A better way of searching multiple files, replacing vimgrep.
• A settings panel exposing options that are hard to find in Vim.
• Window splits.
• Ability to drag tabs between windows.
• Jump to definition & symbol navigation.
• Plugin system.

This involves a lot of work and I would love to be able to work full time on this project. So, I’ve started a campaign over at Indiegogo.

Take a moment to check it out and also share it with your friends. Get perks, make a contribution, or simply follow updates. If enough of us get behind it, we can make HappyEdit happen.

http://www.indiegogo.com/happyedit

Thanks!

Vim can be extended with Ruby and Python if it’s compiled with the +ruby and +python features. If you are using MacVim, you already have them, so you can continue using it happily. But the terminal Vim that comes with your OS X does not support them. Fortunately, we can fix that in less than 5 minutes.

The process is similar to what we described in Fixing the MacVim Cursor Bug on MBP Retina, but this time it’s for the terminal Vim.

If you are a Homebrew user, you can install a new version of Vim by typing the following commands in your terminal:

1
2

$ brew install mercurial
$ brew install https://raw.github.com/gist/3760533/74dd7bf6647c927c782b1cd9ff99e22161e375e9/vim.rb

If you want different compile options, you can fork the gist and customize it as you wish.

If you don’t use Homebrew, you can still compile it by your own. You need mercurial in order to clone the Vim repository. After that, everything is quite straightforward:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$ cd /tmp
$ hg clone https://vim.googlecode.com/hg/ vim
$ cd vim
$ hg update -c 1e22adc6176e
$ ./configure --prefix=/usr/local \
              --enable-gui=no \
              --without-x \
              --disable-nls \
              --enable-multibyte \
              --with-tlib=ncurses \
              --enable-pythoninterp \
              --enable-rubyinterp \
              --with-ruby-command=/usr/bin/ruby \
              --with-features=huge
$ make
$ sudo make install

Please note that we are installing Vim in /usr/local/bin, so it has to be included in your PATH before /usr/bin, where the old terminal Vim is located. You can easily accomplish this by adding the following line in your .bashrc or .zshrc:

1
2
3

# .bashrc or .zshrc

export PATH=/usr/local/bin:$PATH

That’s it! Your Vim with Ruby & Python support is ready for some action.

Replacing text in multiple files is really easy with Vim. However, it’s not quite popular feature and a lot of people don’t know that such exists. In this post we will show you a few tricks that will get the job done.

If you want to replace _params with params in the current buffer, you can do it by executing the following command:

1

:%s/_params/params/ge

However, if the substitution has to be made across all files with extension .rb in a directory, you will have to use argdo:

1
2

:args app/controllers/*.rb
:argdo :%s/_params/params/ge | update

Also you can put the c flag, which will ask for confirmation before each change. Pretty neat, huh?

The limitation of argdo is that it won’t search the supplied directory recursively, but you can use the awesome DirDo.vim plugin to accomplish it:

1
2
3

:DDD app/controllers
:DDP *.rb
:DDO :%s/_params/params/ge | update

Finally, the unix tools sed and awk are always an option that you might consider handy.

After presenting you ”10 Vim color schemes you need to own”, we decided to post a dedicated article with light color schemes. This post is inspired from the feedback that we received from you. Most of the color schemes mentioned here are suggested by our awesome readers. Thank you guys, you rock!

1. pyte

pyte is a light color scheme created by Henning Hasemann. Its main colors are light grey, green and blue. Thanks to Ryan Florence for suggesting it.

2. eclipse

As you can easily guess, eclipse.vim is based on the default colors of the Eclipse IDE. If you have ever done Java development, it should look familiar to you. Let’s thank Juan Frias for creating it.

3. summerfruit256

summerfruit256 is our personal number one. It’s really fresh and it helps you to focus more on the important stuff. The theme is the 256 color version of Armin Ronacher’s summerfruit color scheme. It’s created by Martin Baeuml.

4. AutumnLeaf

The colors of a Finnish autumn morning captured and packed in a nice color scheme, which is light orange/blue/green and doesn’t cause eye strain. It’s handy for Ruby, C/C++, XHTML, CSS and even for Markdown.

5. ironman

Except the awesome name, ironman is a light color scheme that can become your primary weapon when attacking legacy code. It’s all about comfort and productivity. We find it really good option for long coding sessions.

6. nuvola

nuvola is inspired by the Gnome2 SVG theme “nuvola”. It looks really unixy. If you are a Gnome fan, you should consider using it. It’s downloaded more than 2000 times and we are sure that it will gain even more popularity in the future.

7. oceanlight

oceanlight is a light pale blue and green color scheme originally based on oceandeep, intended to be easy on the eyes and not burden you with contrast. Its maintainer is Håkan Wikström.

8. simpleandfriendly

simpleandfriendly is really simple color scheme and that’s why people like it. Thomas Schmall used very eye-friendly colors and put some optical emphasis on comments. It’s perfect for 256 terminals and GUI Vim.

9. buttercream

There are quite a few themes with yellow background. buttercream is probably one of the most popular out there. It’s downloaded more than 1700 times, mostly because it’s really amazing. Håkan Wikström did great job by balancing the colors used in it.

10. solarized

Solarized needs no introduction. Its dark version was featured in our previous post, but the light one looks stunning as well. It’s the primary choice of many developers. Give it a try and you won’t regret it.

But wait, only 10?

Let’s expand our collection even further. What’s your favourite light color scheme? Post it in the comments. Also, if you want to submit a guest post about your favourite theme, just contact us and we will make it happen.

Switch.vim by Andrew Radev is a highly customizable plugin that will help you do substitutions faster than ever.

Usage

The plugin is simple to use, since it has one main entry point - the command :Switch. It’s highly encouraging to map it to a key, as the author suggests in the documentation:

1

nnoremap - :Switch<cr>

It comes with support for Ruby, PHP, Eruby, C and CoffeeScript. However, you can easily add your own switch definitions and make it even more powerful.

You can switch between the following definitions by invoking the :Switch command. Here are some of the built-ins:

• Boolean conditions:

1
2

foo && bar
foo || bar

• Boolean constants:

1
2
3
4
5

flag = true
flag = false

flag = True
flag = False

• Hash style:

1
2

foo = { :one => 'two' }
foo = { one: 'two' }

• If-clauses:

1
2
3
4
5
6
7
8
9
10
11

if predicate?
  puts 'Hello, World!'
end

if true or (predicate?)
  puts 'Hello, World!'
end

if false and (predicate?)
  puts 'Hello, World!'
end

• Rspec should/should_not:

1
2

1.should eq 1
1.should_not eq 1

• String style:

1
2
3

foo = 'bar'
foo = "baz"
foo = :baz

• Coffeescript arrows

1
2

functionCall (foo) ->
functionCall (foo) =>

Customizations

Adding your own definitions is as easy as:

1
2
3
4

let g:switch_definitions =
    \ [
    \   ['if', 'unless']
    \ ]

Now you can easily switch between if and unless:

1
2
3
4
5
6
7

if foo
  # Do something
end

unless foo
  # Do something
end

View the documentation for more advanced examples.

Screencast

You can check out this awesome screencast created by Andrew to see the plugin in action:

We often spend time optimizing our workflow. We learn new technologies, new patterns and constantly improve ourselves. But we often forget about our existing tools and how powerful they are. Vim is one of those tools.

In this article we are going to build a simple Vim plugin, which creates related files. The point is not to teach you some Vim script, but to remind you that your Vim is there and it takes only a few minutes to make it better by writing a few lines of code.

The idea

The idea of our brand new Vim plugin is to help us with our TDD workflow. Every time when you create a new file, instead of creating the test file manually, Vim will magically add it for you. This approach is heavily inspired from the vim-rails plugin, which gives you a simple :A command that opens the related test file.

Before we begin

Since we are Rails developers and we use Rspec a lot, we will create our plugin with them in mind. But don’t worry, you can use it for your favourite language/framework and testing library with just a few tweaks here and there.

Here is a typical Ruby on Rails structure. We need to analyze it before starting with our code:

1
2
3
4
5
6

app/models/user.rb
app/controllers/users_controller.rb
...
spec/models/user_spec.rb
spec/controllers/users_controller_spec.rb
...

So, if we replace “app” with “spec” and “.rb” with “_spec.rb”, then we will get the path of the test file. Hm, that looks easy. But we also have to keep in mind that the file might be already created.

Create related file

Create a new file in your ~/.vim/plugin/ directory with the name related.vim.

All we need to do is grab the filename, figure out if it’s a test file or not and, depending on the result, open/create the associated file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

" Open/Create related spec/file
function! s:CreateRelated()
  let related = s:GetRelatedFile(expand('%'))
  call s:Open(related)
endfunction

" Return the related filename
function! s:GetRelatedFile(file)
  if match(a:file, '_spec\.rb$') != -1
    return substitute(substitute(a:file, "_spec.rb$", ".rb", ""), '^spec/', 'app/', '')
  else
    return substitute(substitute(a:file, ".rb$", "_spec.rb", ""), '^app/', 'spec/', '')
  endif
endfunction

" Open the related file in a vsplit
function! s:Open(file)
  exec('vsplit ' . a:file)
endfunction

" Register a new command `AC` for open/create a related file
command! AC :call <SID>CreateRelated()

You can notice that the new file is opened in a vertical split. This is our preferred workflow, but you can change it by replacing vsplit with split etc.

What’s next?

It feels good, doesn’t it? We are saving ourselves a few second each time when we create a new test file. We’ve learned some Vimscript, as well. If you want to dig deeper, we have some useful resources for you:

• http://learnvimscriptthehardway.stevelosh.com/
• http://www.packtpub.com/hacking-vim-cookbook-get-most-out-latest-vim-editor/book
• http://pragprog.com/book/dnvim/practical-vim

Conclusion

Hacking Vim scripts is easy and totally worth your time. Don’t forget - Vim is probably your greatest tool. It won’t let you down. Spend some time with your Vim files once in a while. Do some crazy experiments, solve some impossible tasks. Don’t worry if it feels like it’s out of your comfort zone. You will become better in time.

What’s your favorite Vim hack? How often do you update your vimrc? Have you learned Vimscript already? What’s your best advice when it comes to writing plugins? Share it with us.

Photo by Velo Steve

There are more than 4000 Vim scripts out there. This is one of the reasons why Vim is so awesome. However, if you are starting with Vim, you might wonder from where to begin. In this post we are going to talk about 5 plugins that can be found in almost any vimrc.

Surround

Surround provides mappings to easily delete, change and add surroundings in pairs. It’s created by Tim Pope, and it’s starred more than 800 times on GitHub.

The best way to explain it is to show some examples:

Go inside the following text and press cs”’:

1

"Hello world!"

It changed the double quotes to single. Cool, isn’t it? You can also remove them by pressing ds".

This plugin is really powerful and it can be extremely useful, check the documentation for more examples.

Command-T

Command-T provides a fast mechanism for opening files and buffers with a minimal effort. Its name comes from the “Go to File” functionality in TextMate, bound to cmd + t.

Command-T is really advanced and it orders the files in your working directory, when searching, by an algorithm which knows that characters in certain locations should have more weight.

You can check this awesome screencast in order to view it in action.

snipMate

snipMate is a plugin created by Michael Sanders. It’s an implementation of TextMate’s snippets features in Vim. A snippet is a often-typed text that you can easily insert by typing a word + tab. Here is an example:

If you are writing JavaScript and you type “for” in insert mode, it will expand a typical for loop:

1
2
3

for (var i = 0; i < Things.length; i++) {
  Things[i]
};

By pressing tab, you can switch between the highlighted items and change them.

snipMate comes with convenient snippets for C, HTML, JavaScript, PHP, Ruby, zsh, Vim and others. Apart from that, you can define your own snippets and make yourself even more productive.

Syntastic

Syntastic is a syntax checking plugin that runs files through external syntax checkers and displays any resulting errors.

There is a support for huge amount of languages, including C, CoffeeScript, CSS, Cucumber, Erlang, Go, Haml, Haskell, HTML, JavaScript, PHP, Python, Ruby.

Buffer Explorer

Bufexplorer is a plugin designed to optimise the browsing of Vim buffers. When you invoke it, it renders a sorted list of all buffers that are currently open. After that, you can easily sort, open or delete any of them.

You can open Bufexplorer by using one of the default public interfaces:

1
2
3

<Leader>be  - Opens BE.
<Leader>bs  - Opens horizontally window BE.
<Leader>bv  - Opens vertically window BE.

What’s your favourite Vim plugin? What are the most useful plugins that you know? Is there a plugin that you consider as really useful, but not quite popular? Let us know in the comments.

Sometimes you just want to have vim configurations per project basis. Imagine how awesome it is to fire up vim with a different color scheme for each one of your projects. You might want to include special plugins for the Node.js project you are hacking on lately. Fortunately, this is extremely easy to accomplish.

Create a file called “vimrc-local.vim” in the ~/.vim/plugin/ directory. After that, put the following 5 lines of code in it:

1
2
3
4
5

" Do we have local vimrc?
if filereadable('.vimrc.local')
  " If so, go ahead and load it.
  source .vimrc.local
endif

Now you can put local vimrc file in any directory of your computer and vim will automatically load it for you. Don’t forget that you have to name the config file “.vimrc.local”. If you prefer a different name, you can replace .vimrc.local with your desired name in the script we just wrote.

1
2
3

$ cd path/to/project
$ ls .vimrc.local
$ mvim . # or vim, etc.

You might be curious what the local vimrc of Vim Ninjas looks like. Here it is:

1
2
3
4
5
6
7
8

" The awesome vividchalk color scheme
colorscheme vividchalk

" Check spelling
set spell

" Monaco 14
set guifont=Monaco:h14

Your editor might look and feel completely different depending on your current focus. Just a few lines of code and you are there. How cool is that?

Photo by Francis Bourgouin

When we installed MacVim on the new MacBook Pro with Retina display, we noticed that the cursor leaves scrapes behind itself. After a little investigation, we found that someone already fired up a bug in the MacVim issue tracker. Björn Winckler reacted almost immediately and the bug is now fixed. However, you need to install the latest HEAD of the MacVim git repository in order to have a version with the patch.

Homebrew

Homebrew provides really convenient command to install and compile the MacVim master branch.

1

$ brew install macvim --HEAD

As simple as that. You are good to go.

However, if you are not a Homebrew user, you have to compile MacVim manually.

Compiling MacVim

First, you have to clone the git repo:

1
2

$ cd /tmp
$ git clone git://github.com/b4winckler/macvim.git

After that, you have to configure and make the project:

1
2
3
4
5
6
7

$ cd macvim/src/
$ ./configure --with-features=huge \
                  --enable-rubyinterp \
                  --enable-pythoninterp \
                  --enable-perlinterp \
                  --enable-cscope
$ make

Voila!

In order to test if everything works fine, you have to start the application by typing:

1

$ open MacVim/build/Release/MacVim.app

If everything looks good, you can open MacVim/build/Release and drag the MacVim icon into your Applications folder.

Conclusion

Besides fixed cursor bug, you will get the latest state of the MacVim project, including performance improvements, fixed bugs, etc. If you find any problems, do not hesitate to open a new issue in the MacVim issue tracker.

It is really exciting to be a Rubyist lately. We have our amazing tools (rake, rspec, Cucumber, Rails etc.), we write object-oriented code, that is easy to maintain and flexible when it comes to adding new features, and changing domain logic. We have amazing hosting support from Heroku, Engine Yard and Rackspace. And last, but not least, powerful monitoring tools like New Relic are ready to tell us when there are issues in our applications. But do we have the perfect editor? A lot of people are still using TextMate, some of them started the journey of Sublime Text 2 and others made different choices (Emacs, RubyMine, TextMate 2 etc). And how about Vim? Do we have healthy community of Rubyists in the Vim world? Is it worth giving it a try? Let’s find out.

Rubyists using Vim

Big percentage of the Rubyists are actually using Vim. Here are some of the most popular Vim evangelists out there:

Gary Bernhardt - Gary is the creator of Destroy all Software. Watching him in action with Vim is really inspirational. Subscribe to his screencasts and you will find out what we are talking about. You can learn a lot of useful Vim tricks by watching him write Ruby code.

• Twitter: @garybernhardt
• Vimfiles: GitHub

Aaron Patterson (tenderlove) - Tenderlove is a Ruby and Rails core team member. He is super positive person, spending a lot of his time making Rails and Ruby faster. So, thank you for that Aaron! Also, it’s a well-known fact, that he prefers Vim over other editors. You can watch him using Vim in this PeepCode Play by Play episode.

• Twitter: @tenderlove
• Vimfiles: GitHub

Mislav Marohnić - Mislav is a software craftsman from Croatia. He is contributing to Zepto and Rails among others. He wrote the famous “Vim: revisited” blog post, that inspired many people to start using Vim.

• Twitter: @mislav
• Dotfiles: GitHub

(Your name here? Are you a Rubyist using Vim? Send us your short introduction + links to your twitter account and dot files and we will feature you in the post)

Vim plugins for Ruby development

Vim Ruby

Vim Ruby is probably the most popular Vim plugin for Ruby development. It can be found in pretty much every vimrc owned by a Rubyist. It comes with mappings that make editing Ruby code much easier.

1

imap <S-CR> <CR><CR>end<Esc>-cc

This enables:

1

if name == "John"[<--cursor]

And when you press shift + enter:

1
2
3

if name == "John"
  [<--cursor]
end

(Note: you can accomplish the same behaviour with endwise even without pressing shift).

Files with a filename extension of .rb or a ruby shebang line (#!/usr/bin/ruby) will be set to filetype “ruby”. It brings mappings, options, matchit configuration etc.

If Vim Ruby is not in your Vim configurations you should definitely consider including it.

Vim Rails

Oh, Rails! Yes! Tim Pope did an amazing job with Vim Rails. It’s probably the most useful plugin we’ve ever used. If you are a Rails developer, you will get a lot benefits just by installing it. Here are some useful examples:

Easy navigation of the Rails directory structure

You can easily jump to alternative files, for example to specs from production code, by typing :A or :AV if you prefer to open it in a split window. Also, if you want to jump from a controller action to the view file or vice versa, you can press :R. Navigation between models, controllers and views is getting even easier with the following commands: :Rcontroller controller-name, :Rmodel model-name etc.

Enhanced syntax highlighting

The plugin adds syntax highlighting for has_and_belongs_to_many, has_many etc. Better completion is provided as well.

Interfaces to rake & Rails scripts

You can use :Rake to run the current spec or feature. :Rscript is available for convenient execution of scripts without leaving your favourite editor.

Partial extraction & migration inversion

:Rextract file can extract the current visual selection to file and replace it with render partial: 'file'.

Ruby Refactoring

Ruby Refactoring is a plugin written by Enrique Comba Riepenhausen and inspired by some Ruby refactoring patterns that Gary Bernhardt presented in the Software Craftsmanship User Group UK.

You can easily add new parameters, inline temporary variables, extract constants and more. Here is the full list of supported commands:

1
2
3
4
5
6
7
8

:RInlineTemp             - Inline Temp
:RConvertPostConditional - Convert Post Conditional
:RExtractConstant        - Extract Constant
:RExtractLet             - Extract to Let (Rspec)
:RExtractLocalVariable   - Extract Local Variable
:RRenameLocalVariable    - Rename Local Variable
:RRenameInstanceVariable - Rename Instance Variable
:RExtractMethod          - Extract Method

For most of the commands you will need to install matchit.vim as well.

Vim Cucumber

Who doesn’t use Cucumber these days? We spend a lot of time writing acceptance tests, so we need an environment that is going to help us to focus and refactor them better.

Vim Cucumber provides syntax highlighting, indenting, and a filetype detection for Cucumber. You can use CTRL-] on a step to jump to its Ruby definition or, if you prefer splits, you can use CTRL-W-], like we do. Pretty useful, right?

Vim Haml/Slim/Sass

As Ruby developers we always use the latest and the greatest. It’s all about writing beautiful code that is easy to maintain, isn’t it? That’s why we use Haml, Slim and Sass. But Haml without syntax highlighting isn’t really useful. Fortunately, there are a few plugins that will help you using your favourite frontend tools:

• vim-haml - runtime files for Haml and Sass.
• vim-slim - similar to vim-haml, but for Slim.
• vim-less - Less highlighting, indenting and autocompletion.

Janus

If you are just starting with Vim, coming from TextMate or other editor, you can give Janus a shot. It’s a distribution of plugins and mappings for Vim, Gvim and MacVim. It’s bundled with a lot of useful tools for Ruby development and designed to reduce the learning curve of Vim. Apart from that, the community behind it did an amazing job by making it extendable, so you can include your own configurations and plugins with no effort. Gundo, ctrlp, easymotion, supertab, surround are just a few examples that come with Janus.

And even more

Apart from the plugins and the resources mentioned in the article, here is a list of some useful links to resources, that will make you even more productive Rubyist:

• endwise - adds end after if, do, def and several other keywords.
• snipmate - TextMate like snippets for Vim
• vim-rake - With rake.vim, you can use all those parts of rails.vim that you wish you could use on your other Ruby projects
• vim-bundler - This is a lightweight bag of Vim goodies for Bundler
• Vim refactoring series - Introduction to vim refactoring.
• Using Vim as a Complete Ruby on Rails IDE - Vim for Ruby.
• How to use Vim with Rails - Cool post about Vim and Rails.
• Compiling Vim with Ruby support - How to compile Vim with Ruby support.
• Ruby autocomplete - Autocompletion for Ruby in Vim.
• Vim for Ruby and Rails - Getting started with Ruby, Rails and Vim
• From TextMate to Vim - Useful for people coming from TextMate
• Intro - Rails Vim - Rails and Vim

Conclusion

There are a lot of Rubyists doing web development with Vim. Besides being ruby evangelists, they also contribute to a huge amount of Vim plugins. So, if you are going to migrate to Vim, you are in a good company.

What’s your favourite Vim plugin for Ruby? Do you have any special Vim tricks for writing Ruby code? Which Vim features had the greatest influence on you? Let us know in the comments.

There are a lot of Vim color schemes out there. It’s always hard to find the perfect one. People often use different color schemes depending on what they are working on. This is pretty neat approach that has plenty of supporters. That’s why we did a quick overview of our top 10 themes. Let’s go:

1. GRB256

GRB256 is a color scheme based on ir_black by Gary Bernhardt. It feels really nice especially for Ruby on Rails development, so give it a try.

Download: GitHub

Author: Gary Bernhardt

2. Guardian

Guardian is originally created for XHTML and CSS editing, however you can use it for Ruby and JavaScript development as well.

Download: Vim.org

Author: M. L. (anderskorte)

3. Codeschool

The author created this color scheme to mimic the CodeSchool theme used in their Rails Best Practises course. It is ported to Vim using Coloration.

Download: astonj

Author: AstonJ

4. Distinguished

Distinguished is a dark Vim color scheme for 256-color terminals. It’s often used in the terminal Vim. It’s perfect for JavaScript development. Works great for Ruby and Python too.

Download: GitHub

Author: Kim Silkebækken

5. GitHub

This color scheme is a port of GitHub’s light-background syntax highlighting theme. It looks good with completion menus, diffsplit, STL highlighting and more.

Download: Vim.org

Author: Anthony Carapetis

6. Jellybeans

Jellybeans is a colorful color scheme, inspired by ir_black and twilight. It’s designed primarily for gVim/MacVim, but also includes support for 256 color terminals.

Download: GitHub

Author: nanotech

7. Railscasts

Ryan Bates ported his TextMate color scheme used in the RailsCasts episodes to Vim. If you write Ruby code most of the time, you should definitely try it.

Download: GitHub

Author: Ryan Bates

8. Twilight

Twilight is a clone of TextMate’s twilight scheme. There are a lot of Twilight clones out there, but it seems this is the most preferred. It’s not exactly the same as the original, but in some cases it feels even better. If you are coming from TextMate, we encourage you to give it a try.

Download: Vim.org

Author: Henning Hasemann

9. Vividchalk

This color scheme is another theme ported from TextMate to Vim. It is based on the Vibrant Ink theme TextMate. GUI, 256, 88, and even 16 color terminals are supported.

Download: GitHub

Author: Tim Pope

10. Candy

Candy is one of the hidden color schemes in the Vim world that you can’t find easily. Feel free to download it and use it right away.

Download: Vim.org

Author: Tiza

Bonus: Solarized

You almost thought it won’t be included, didn’t you? Solarized is probably the most popular color scheme out there. If you haven’t tried it yet, you should download and start using it immediately.

Download: GitHub

Author: Ethan Schoonover

As you can easily guess we prefer dark color schemes. However, if you know amazing light theme that deserve to be included just send us a link and it will be featured in the list.

What’s your favourite color scheme? Do you prefer different color schemes for terminal Vim and MacVim/gVim? Let us know.