Reliable way to open files given by the result of find … -exec grep … {} \+

Question

I often run commands like this:

find … -exec grep … --color=always -l {} \+

and sometimes I need to open the matching files in Vim.

But what is the most reliable way to do so?

One way seems to be

vim $(find … -exec grep … {} \+)

Another way seems to make use of xargs.

Are there advantages/disvantages/concerns to be aware for these two, and others, if any, methods?

Answer 1

vim $(find path/ -exec grep -l 'pattern' {} +)

is an unquoted command substitution, so word splitting will be performed on whitespace on its result, as well as pathname expansion. I.e., if a file a b matches, Vim will incorrectly open a and b. If a file * matches, alas, that will be expanded to every file in the corresponding directory. An appropriate solution is

find path/ -type f -exec grep -q 'pattern' {} \; -exec vim {} +

Grep runs in quiet mode: Only its return value is used for each file. If 0, a match was found in that file and the file is passed on to Vim.

{} \; means one file will be analysed at a time by Grep. If we used {} +, all files would be passed as arguments to Grep, and a found match in any of those files would result on 0 exit status, so all those files would be opened in Vim. On the other hand, {} + is used for Vim so that it each found file goes to one buffer in a single Vim process. You can try changing them to feel the difference.

If you need to speed things up:

• If 'pattern' is not a regular expression, but only a fixed pattern, add the -F flag to Grep.

• grep -lZ, Xargs and special shell constructs should also speed-up the process if you have those available, see Stéphane Chazelas' answer.

And here are another similar use cases with Xargs, Find and Vim.

Answer 2

With GNU tools (your --color=always is a GNU extension already) and a shell with support for Ksh-style process substitution:

xargs -r0a <(grep -rlZ pattern .) vim

Or:

xargs -r0a <(find . ... -exec grep -lZ pattern {} +) vim

With zsh:

vim ${(0)"$(find . ... -exec grep -lZ pattern {} +)"}

With bash 4.4+:

readarray -td '' files < <(find . ... -exec grep -lZ pattern {} +)
vim "${files[@]}"

Those minimise the number of grep invocations that are performed. The point is to tell grep to output the file names NUL-delimited, so they can be reliably split into separate arguments for vim by GNU xargs -0 or zsh's 0 parameter expansion flag or bash's readarray -td ''.

In zsh, you could also do:

vim ./**/*(...e['grep -q pattern $REPLY'])

(where ... stands in for further qualifiers you may want to add, like for the find approach).

That means however that like the approaches that use find -exec grep -q pattern {} ';', one grep invocation would be run per file which would make it significantly slower.

Your first approach would work in zsh provided you replaced --color=always with -Z and changed the value of IFS to IFS=$'\0' from the default of IFS=$' \r\n\0'. I wouldn't work in other shells, as they don't support storing NULs in variables, let alone $IFS and would also perform filename generation on the words resulting of the splitting which you'd need to disable with set -o noglob or set -f.

Why is looping over find's output bad practice? will give you more tips on how to process the list of files found by find reliably.

Answer 3

Two different approaches:

1. Put the results in a quickfix list:

find ... -exec grep -Hn {} + >results
vim -q results

Or the cleaner (but non-sh)

vim -q <(find ... -exec grep -Hn {} +)

2. Use :grep -R and :Cfilter:

vim
:grep -R ...
:packadd cfilter
:Cfilter[!]

See the relevant :help for some of the commands.

Either way, you can navigate matches with :cnext and the other :help quickfix commands.