Today I learned: Vim

Fuzzy finding with FZF.vim

Wed, 06 Jan 2016

I’ve been through my fair share of Vim file finding plugins. I first started with Command-T before moving on to CtrlP. I then stole a colleague’s set up which used Gary Bernhardt’s selecta finder. You can find the config for that in my old vimrc.

That had been serving me well but I then stumbled upon Junegunn Choi’s excellent fzf, a great fuzzy finder that (from my experience so far) seems incredibly quick and extremely reliable. Thankfully he’s also created fzf.vim, a Vim wrapper around some common functionality that fzf provides. It’s this that I want to show you today.

Installing is fairly straight forward, and it’s recommended you use Vim-Plug to do it:

Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' } Plug 'junegunn/fzf.vim'

Once done you’ll have access to a bunch of new commands that will use fzf to find files, lines and more.

Finding Files

You can use the :Files command to search for files in your directory.

Finding Commits

I’m also a big fan of the :Commits command, which fuzzy searches through your git commits. Note that you need Fugitive.vim for this to work.

Matching Lines

You can also use the plugin in insert mode to perform linewise completition based on what you’ve already typed! I’ve mapped this like so:

imap <c-x><c-l> <plug>(fzf-complete-line)

As shown in the fzf.vim README. This is really useful when you need to type a line you know you’ve typed before - for example, an import or require statement. This is effectively Vim’s linewise completion on overdrive!

Conclusion

fzf.vim has really added a lot to my Vim setup and workflow - once you get used to fuzzy finding everything you’ll never look back, and I highly recommend giving it a go.

Opening URLs from Vim

Sun, 08 Feb 2015

Big thanks to Keith Smiley for this tip to kickstart this blog once more!

Just discovered gx in vim. Totally amazed at how often I find things that will massively improve my usage.
— Keith Smiley (@SmileyKeith) February 8, 2015

From within Vim if you position your cursor over any URL and hit gx, the URL will be opened in your default browser. Simple and incredibly effective!

Tmux and Vim: the perfect combination

Wed, 30 Jul 2014

Last night at Vim London I spoke about some of my favourite plugins and settings for Tmux and Vim that allow me to work with them as I do. It’s very rare these days that I won’t be editing code from Vim, within a Tmux session, but out of the box the immediate advantages of this pairing are not always obvious. It takes some time to get things working.

The talk was recorded and I will update the post with it once it’s public, but for now I just wanted to link to some of the plugins and settings I mentioned in the talk that I use in my dotfiles.

`tnew` alias

I create all my tmux sessions through an alias I have which I’ve called tnew, which simply calls a function called new-tmux-from-dir-name (this is taken from the thoughbot dotfiles. The function looks like so:

sh function new-tmux-from-dir-name { tmux new-session -As `basename $PWD` }

This does two things: - when you create a new session, it names it based on the directory name - if you are in a directory that already has a tmux session associated, tnew will attach you back into the already existing session

Tmux + OS X, `pbcopy`

By default tmux on OS X breaks the pbcopy command. I’m not going to go into details, but thankfully Chris Johnsen’s fix has detailed instructions on how to get that functionality back, and it’s not too tricky either.

Renumber windows

Out of the box, if you have 3 tmux windows numbered 0, 1, 2 and then you delete the one numbered ‘1’, you’re left with two windows: 0, and 2. This is rather odd when you navigate between them. However, you can tell tmux to renumber existing windows automatically with this line in your tmux config:

set-option -g renumber-windows on

vim-tmux-navigator

Without a doubt, this is the one thing that makes working with Vim and Tmux so much better, Chris Toomey’s vim-tmux-navigator plugin. By installing this and adding a few lines to your tmux config (instructions are in the README), this lets you seamlessly jump between Vim and tmux panes (or splits, as Vim calls them) with the same keystrokes. This means if you have a Vim split next to a tmux pane, you can hop between them even though one of them is Vim, and the other is tmux. It’s fantastic, and really ups the intergration of these two tools by another level.

Vimux

Although there are many choices, I personally have taken to using Vimux, a plugin which lets you send any command to a tmux pane (which it will create if it doesn’t already exist). This means I can set up mappings for running specific commands, such as for testing:

viml map <leader>nt :call VimuxRunCommand("clear; npm test")<CR>

It also has a function which you can run that will prompt you for a command, which I have mapped to <leader>x:

viml map <leader>x :VimuxPromptCommand<CR>

tmux-complete

This plugin adds any word visible in a tmux pane to a completion function that you can trigger with <C-X><C-U>. It’s rare that I want to type something in Vim that I can see in a tmux pane, but when I do this plugin is always useful and saves coming out of Vim to grab some text.

So that’s just some of the plugins I use daily when working with tmux and Vim. If you have any to recommend, please do leave a comment!

Ruby text objects

Fri, 18 Jul 2014

Yesterday I discovered a text object within Vim that I’d not realised existed, which served as a perfect tip post up onto this blog (and to try and get back to doing it more regularly!).

Any seasoned Ruby + Vim user has probably got Drew Neil’s textobj-rubyblock plugin installed, which adds the text objects ar and ir to select around and inside a ruby block.

However, what I didn’t know about was the text object im, which is provided by vim-ruby (which comes with Vim by default), to select the contents within the current Ruby method, and its sibling am, to select around the method. Hat tip to @tomstuart for that one:

It took me a few minutes to work out how to select the body of a Ruby method in Vim, but I was happy when the answer turned out to be “vim”.
— Tom Stuart (@tomstuart) July 17, 2014

Drew Neil (@nelstrom)) then followed up explaining that it was recently added to vim-ruby:

@telemachus it’s a text object defined in the vim-ruby plugin: https://t.co/YZSmUPWr0P Should be available out the box in recent Vim builds.
— Drew Neil (@nelstrom) July 17, 2014

If you’re running a recent version of Vim you should have this functionality, but if you’re not, you can always install the latest version of vim-ruby as a plugin through Vundle / Pathogen. The best solution though if possible is to simply upgrade your Vim.

Whilst reading to produce this blog post I also discovered the objects iM and aM, which select in and around the current Ruby class, too. All of these are going to be really useful in my day to day development.

Recording Macros for Super Efficiency

Thu, 01 May 2014

Macros in Vim can be a great time saver, especially for complex and repetitive line-editing tasks. A macro is a way of recording a series of actions as a single command. I find this especially useful when I need to make some formatting changes to a set of lines. This is perhaps best illustrated by an example, but prior to that let us quickly look at the syntax for recording and using macros in Vim.

Recording a macro is split into three steps:

q followed by a letter to start recording. The letter can be any valid register of your choice, e.g. m. If successful you will see recording in the bottom left of the screen.
Carry out whichever actions you require. This isn’t constrained to just one line of actions, though often this is practical.
Press q again to stop recording.

Using a macro is simply a case of typing @ followed by the register character chosen, m in the previous example.

A brief example

An example may make the benefits of macros clearer. Let’s say that we have the following data in a file and we want to transform this into a CSV file. This chunk of data is from a wireless sensor network log file that really did need converting to CSV.

StandDev (ToF): 2260ps, Mean (ToF): 64037ps, Errors: 0
StandDev (ToF): 2265ps, Mean (ToF): 66037ps, Errors: 0
StandDev (ToF): 2184ps, Mean (ToF): 82858ps, Errors: 1
StandDev (ToF): 3184ps, Mean (ToF): 82860ps, Errors: 1
StandDev (ToF): 1439ps, Mean (ToF): 55893ps, Errors: 0
StandDev (ToF): 2439ps, Mean (ToF): 75893ps, Errors: 3

We can change this to form part of a CSV file with a quick macro:

Move to the first line we wish to edit (remember, the macro will capture all commands, so if you execute a move command in your macro it will happen on each run).
Start recording, qm
Execute our edit steps. This can be done in many ways. The example command sequence below prepares a single line by: moving to the start of the line, systematically removing the words and units, adding a trailing comma.
```
  ^2df fpxxf 2df fpxxf df A,^[j
```
- ^[ is the ESCAPE key
- Note the move down to a new line at then end, j. We don’t have to use this approach, alternatives include starting our macro with a search, or using the normal command to run the macro on a selection of lines.
Stop recording, q

With our macro recorded we can now easily run this on the remaining lines, in our case five times, starting from the first unedited line using 5@m. As with many efficient uses of Vim, the power in macros really becomes apparent for cases where the task is very repetitive.

Macros are a good way of making you think about the commands you are using. This becomes more apparent when working on files that are varied. The example above was originally taken from a log file that had many other lines of different data, some already in the correct format. To get to a relevant line for the macro to operate on I included a search for ‘StandDev’ at the start of the recorded command sequence.

Remember, @ simply treats the proceeding register as a list of commands. This means a register used for a macro can be viewed and edited in the normal ways. This provides a convenient way to fix any mistakes made during the recording of a macro, by editing the register. The Macros page at wikia has a good explanation of this, notably including a section on saving macros — really useful if you know you will need your finely-crafted macro for future files.

Hopefully this post has shown the advantages macros offer in Vim, especially for those that do a lot of one-time text transformations.

Guest post by Martin Falkus (@mfalkus).

Better Pasting from the Clipboard

Tue, 18 Mar 2014

Something I find myself doing fairly regularly is copying something from outside of Vim into Vim. Usually this is something like a chunk of code from a Stack Overflow post, or a new reference to add to my Bibtex file (I’m in the middle of my University dissertation…). The problem with pasting some code in is, as you’ve probably seen, that Vim tries to indent the code as you paste it. If the code already has indents (which usually it does) this is a bit of a nightmare, as you end up with incorrect indenting and have to perfom == on a number of lines to correct it.

There is a better way. We can run :set paste, which tells Vim to be in paste mode. In this mode, when you’re in insert mode and paste in, Vim will not perform any indenting itself, and let what you’re pasting in dictate it. You can then run :set nopaste to turn off paste mode.

This is good, but it’s still too many steps for me:

Exit insert mode.
Run :set paste
Go into insert mode.
Hit Cmd+V to paste in.
Exit insert mode.
Run :set nopaste.

That’s far too much work, and far too many keystrokes. Thankfully, we can turn this into a handy mapping. I should add that credit for this mapping goes to Ben Orenstein, as it was taken directly from his .vimrc file, all I’ve done is write it up as I thought it warranted it. Here’s the mapping:

map <Leader>p :set paste<CR>o<esc>"*]p:set nopaste<cr>

Let’s step through that:

:set paste<CR> turns on paste mode
o<esc> inserts a new line below and goes back into normal mode
"*]p gets the content from the system clipboard, and pastes it in.
:set nopaste<cr> turns paste mode off.

The one oddity there is the use of ]p instead of p to paste in. Vim’s help can solve that one, :h ]p:

Like "p", but adjust the indent to the current line.

Effectively it applies the indent within the pasted content from the indent level that you’re at when you invoke the pasting.

This is a great example in my opinion of the power of Vim and its mappings - this mapping in particular is one I use multiple times a day and really does save me time and keystrokes.

vim-dispatch: I should have used this years ago

Thu, 13 Mar 2014

vim-dispatch is a plugin by Tim Pope that I’d heard a lot about but never really understood the benefits or what it offered me…until now.

Recently I’ve been working a lot with Makefiles. I’m writing my dissertation in Latex and compiling that through a Makefile, I have a couple of C projects which I’ve similarly used Makefiles to save me time, and I’ve also been using other build tools like Gulp, Grunt, or other command line tools like Bundle.

Essentially, something I have to do quite a lot is quickly drop out of Vim to run something, usually one of the aforementioned tools or often my tests too. The problem with these is that they take my focus out of Vim. Most of the time as well, I only care about the result of the program I ran if something went badly. If everything went OK, I don’t need to know. So taking my focus out of Vim and losing where I was isn’t worth it most of the time.

And that’s where Vim Dispatch comes in. It provides two commands. The first, :Make wraps around Vim’s :make, but runs it asynchronously, in the background. Then, once its done, it populates the quickfix list with any problems or errors. If nothing bad happens, you don’t get disturbed. And, most importantly, at no point is your focus taken from Vim. You can keep typing away and coding as your Make command runs in the background. The output from the command is added to the quickfix window, and the quickfix window is populated with the errors. If there is no error, there is no quickfix window population and nothing happens.

If you don’t want to run Make, but would like to run other commands asynchronously, that’s possible too. Dispatch provides a :Dispatch command for just this. Some examples:

:Dispatch bundle install
:Dispatch rspec %
:Dispatch grunt test

These work exactly as the :Make command, but will just run anything you pass it.

Depending on the context on which you run Vim, Dispatch will run what you give it differently. In tmux, which is where I spend most of my time, it will open a split and run it there. If you’re in iTerm on a Mac, it opens a new window. If you’re not in either, it will just run it in the background entirely. It also has Windows support.

And for those longer running tasks, you can use :Make! and :Dispatch!, which run in the background and don’t disturb you at all. When you need to get feedback from that task, you can hit :Copen to view any output.

I seriously recommend checking out Dispatch if you commonly find yourself jumping out of Vim to run a command. It’s really changed my workflow and decreased the time spent jumping out of Vim, which is a massive timesaver.

Repeating last command-line with `@:`

Wed, 29 Jan 2014

Once you’ve used Vim for a while you become accustomed to repeating the last change in normal mode with .. Being able to repeat actions easily lends itself to some efficient workflows and Vim also provides a way of repeating the last command-line action from normal mode using @:.

I find @: useful to repeat commands such as :cn / :cp to navigate the quickfix list, :bd to easily close a bunch of files and to repeat the last substitution.

See :help @: for more.

Guest post by Matt Walker (@_walkermatt).

Automatic Comment Prefixing Revisited

Mon, 30 Dec 2013

A while back, I wrote about removing Vim’s automatic comment prefixing. This behaviour is turned on by default, and is best shown with an example:

# some comment {cursor here}

If I was to hit o or O, to insert on the line above/below, or be in insert mode and hit enter, Vim would automatically add the comment prefix for me, so it would look like this:

# some comment
# {cursor here in insert mode}

Vim has automatically added the # for me.

I am not a fan of this, and in my original post I advised adding this line to your vimrc to fix it:

set formatoptions-=or

However, that stopped working for me (I’m not sure when - or if it’s related to a new Vim version). Today I managed to figure out the solution. This line does the trick:

 autocmd FileType * setlocal formatoptions-=r formatoptions-=o

To be honest, I’m not sure why the original doesn’t work, and if anyone does, please leave a comment, as I’d be really interested to know why. If you’ve had the same problem, try the new line and see if that solves it.

Swapping Pathogen for Vundle

Sat, 28 Dec 2013

I’ve been a big fan of Tim Pope’s pathogen for managing my Vim plugins. I wrote a small Ruby script to manage the process of cloning from GitHub, and everything was fine.

However, recently, a lot of people have been talking about Vundle. Vundle takes the process of cloning repositories and manages it all for you, so there’s a lot less work for you to do manually.

The process of setting up Vundle is very straight forward. Firstly, clone Vundle:

git clone https://github.com/gmarik/vundle.git ~/.vim/bundle/vundle

Now it’s just a case of editing your vimrc. Vundle requires you to add a few lines to your vimrc file. Make sure these lines are at the very top:

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

Vundle requires filetype to be off initially, but once you’re finished adding Bundles, you can set it to be on again. Next, load in some bundles. Note that you have to load in the vundle repo first:

Bundle 'gmarik/vundle'
Bundle 'tpope/vim-endwise'
Bundle 'tpope/vim-git'
Bundle 'tpope/vim-surround'
...and so on...

Vundle will look on GitHub by default for those URLs, but you can also pass it a direct Git URL or even a local Git path.

After all your Bundle calls, you are free to add whatever you like to your vimrc, including setting filetype back to on:

filetype on

Now, you can install your plugins by running :BundleInstall within Vim (you’ll need to restart Vim or source your vimrc once more before). In the future, if you want to update your plugins, you can run :BundleInstall! to update. If you remove a plugin from your vimrc, you can run :BundleClean to remove the old plugin.

For me, the main advantage of Vundle is less overhead on my part. I’ve been able to delete my Ruby script for managing my Vim plugins, and the relevant commit in my dotfiles shows just how much I was able to delete. Keeping the configuration within the vimrc and just using Vundle’s functions to pull everything together makes a lot of sense.