DEV Community

loading...

Interactive Fuzzy Finding in Vim without Plugins

Peter Benjamin (he/they)
Software Engineer. {Go,TypeScript,Rust}. Kubernetes.
・4 min read

Table of Contents

Overview

FZF is a great command-line fuzzy-finder and there is fzf.vim plugin that integrates with Vim to provide features, like :Files to fuzzy search over files and :Rg to fuzzy search over text using ripgrep.

Recently, however, I have been experimenting with a plugin-free Vim setup and while :find is sufficient for some use-cases, I found myself quitting vim and running fzf to find deeply nested files in new or large projects.

There has to be a simple way to integrate a command-line program with a command-line editor, right?

The Setup

This setup is simple and it leverages a feature in vim called quickfix.

The flow is:

  1. Call fzf
  2. Format the output to make it compatible with errorformat
  3. Write the results to a temporary file
  4. Load the results into Vim's quickfix list with :cfile or :cgetfile, so that we can navigate through the results with :cnext/:cprevious or :copen
  5. Clean up temporary file

Here is what the final vimscript looks like:

function! FZF() abort
    let l:tempname = tempname()
    " fzf | awk '{ print $1":1:0" }' > file
    execute 'silent !fzf --multi ' . '| awk ''{ print $1":1:0" }'' > ' . fnameescape(l:tempname)
    try
        execute 'cfile ' . l:tempname
        redraw!
    finally
        call delete(l:tempname)
    endtry
endfunction

" :Files
command! -nargs=* Files call FZF()

" \ff
nnoremap <leader>ff :Files<cr>
Enter fullscreen mode Exit fullscreen mode

A quick breakdown:

  • let l:tempname = tempname()
    • Generate a path to a temporary file and store it in a variable.
    • See :h tempname()
  • execute 'silent !fzf --multi ' . '| awk ''{ print $1":1:0" }'' > ' . fnameescape(l:tempname)
    • Call fzf with --multi to allow for selecting multiple files
    • Pipe to awk to append :1:0 to fzf results to make them errorformat-compatible.
    • Note: you can drop this awk command if you set errorformat+=%f in your vimrc, but I found %f to capture a lot of false-positives from other programs' outputs and therefore :cnext/:cprevious don't function on these false-positive results.
    • Finally, direct the results into the temp file
  • execute 'cfile ' . l:tempname
    • Load results from temp file into quickfix list and jump to the 1st result.
    • Note #1: you may use :cgetfile to only load results into quickfix list without jumping to the 1st result.
    • Note #2: you may replace :cfile/:cgetfile with :lfile/:lgetfile to use location list instead of quickfix list. Location lists are window-specific, whereas quickfix lists are global. So if you prefer to have different set of results per vim window, then use :lfile/:lgetfile.
  • call delete(l:tempname)
    • Clean up by deleting the temp file
  • command! -nargs=* Files call FZF()
    • Invoke FZF() function when we call :Files in vim
  • nnoremap <leader>ff :Files<cr>
    • Normal-mode mapping so that we can trigger this flow with <leader>ff

Bonus

While :set grepprg=rg\ --vimgrep is again sufficient for most of my use-cases, those who have used :Rg in fzf.vim will appreciate the interactive fuzzy grepping experience and the ability to preview results before opening files in vim.

Well, here is a similar experience with pure vim (obviously, fzf and rg binaries are still required):

function! RG(args) abort
    let l:tempname = tempname()
    let l:pattern = '.'
    if len(a:args) > 0
        let l:pattern = a:args
    endif
    " rg --vimgrep <pattern> | fzf -m > file
    execute 'silent !rg --vimgrep ''' . l:pattern . ''' | fzf -m > ' . fnameescape(l:tempname)
    try
        execute 'cfile ' . l:tempname
        redraw!
    finally
        call delete(l:tempname)
    endtry
endfunction

" :Rg [pattern]
command! -nargs=* Rg call RG(<q-args>)

" \fs
nnoremap <leader>fs :Rg<cr>
Enter fullscreen mode Exit fullscreen mode

This offers the same experience where:

  • :Rg without arguments will load all text into vim and allow users to interactively type and preview results before selecting files
  • :Rg [pattern] will pre-filter results to just ones that match [pattern] before passing them to fzf for further fuzzy searching.

Caveat

In my testing, I found one major caveat that did not impact me too much, but it is still worth calling out here:

Executing shell commands in vim with bangs, like :!fzf, is not meant to be interactive (at least, not out of the box). This could be a problem in GVim/MacVim. The vim docs mention the following workaround:

On Unix the command normally runs in a non-interactive shell. If you want an interactive shell to be used (to use aliases) set 'shellcmdflag' to "-ic".

Setting shellcmdflag=-ic could incur a time penalty, depending on your shell startup/initialization times.

Summary

Vim is extremely versatile and customizable.

With some knowledge of vim concepts (e.g. quickfix, :cfile/:lfile) and a little bit of (vim & bash) scripting, you can achieve a richer experience and pleasant integrations to enhance your productivity in a way that suits you and your workflow.

I hope you enjoyed this post and I hope it inspires you to develop and share your productivity tips and tricks in vim.

Happy hacking!

Discussion (1)

Collapse
moopet profile image
Ben Sinclair

I use fzf as a plugin, but I also have a couple of shell scripts to start things up. My most used one I call vrg and it allows me to search for something using whatever seach tool I have installed, select the matches I want through fzf (if installed) and open them all in my configured EDITOR because I love being generic.

It's a bit pointless, tbh, because the same script that installs vrg also installs all the dependencies I prefer. I could have made it a quick alias! But it's become a workflow habit.