Efficient way to refactor a class/method/string within a directory using vim

Question

So far, I have been manually refactoring code by using the find-and-replace operation

%s:/stringiwanttoreplace/newstring/g 

in vim.

But this is a slow and laborious process if I have stringiwanttoreplace in many files inside a specific directory.

My current/typical slow and laborious process involves a grep:-

grep -rn "stringiwanttoreplace" .

in my terminal to reveal all the locations/filenames where stringiwanttoreplace are; and now that I know which files contain stringiwanttoreplace, I will open each file one-by-one to perform the find-and-replace operation in each file.

Is there a more efficient workflow (in vim) to get this done?

CLARIFICATION: I would prefer a vim-based solution instead of a bash script/one-liner.

Answer 1

Here's the full sequence of commands that I would use:

/stringiwanttoreplace
:vimgrep /<c-r>// **
:Qargs
:argdo %s//newstring/g
:argdo update

In the first line, we search for the target pattern. That populates the last search pattern register (:help quote/), which means that we won't have to type it out in full again.

The :vimgrep command searches the entire project for the specified pattern. Type <c-r>/ as ctlr+r followed by / - this inserts the contents of the last search pattern register onto the command line. The first and last / symbols are delimiters for the search field. The trailing ** tells Vim to look inside every file and directory below the current directory.

At this point, the quickfix list will be populated with search matches from all matching files. :Qargs is a custom command, which populates the argument list with all of the files listed in the quickfix list. Here's the implementation:

command! -nargs=0 -bar Qargs execute 'args ' . QuickfixFilenames()
function! QuickfixFilenames()
  " Building a hash ensures we get each buffer only once
  let buffer_numbers = {}
  for quickfix_item in getqflist()
    let buffer_numbers[quickfix_item['bufnr']] = bufname(quickfix_item['bufnr'])
  endfor
  return join(values(buffer_numbers))
endfunction

Add that to your vimrc file.

Having run :Qargs, our argument list should now contain all of the files that include our target string. So we can run the substitution command with :argdo, to execute the command in each file. We can leave the search field of the substitution command blank, and it will automatically use the most recent search pattern. If you want, you could include the c flag when you run the substitution command, then you'll be prompted for confirmation.

Finally, the :argdo update command saves each file that was changed.

As @Peter Rincker pointed out, you should ensure that Vim's 'hidden' option is enabled, otherwise it will raise an error when you try to switch to another buffer before writing any changes to the active buffer.

Also, note that the last 3 commands can be executed in a single command line, by separating them with a pipe character.

:Qargs | argdo %s//replacement/gc | update

The :Qargs command is pinched from this answer (by me), which in turn was inspired by this answer by DrAl. A very similar solution was posted by @ib, which suggests to me that Vim should really implement something like :quickfixdo natively.

Answer 2

You can call this from within Vim (:!find ...) but you don't need to:

find . -type f | xargs sed -i 's/stringiwanttoreplace/newstring/g'

Fine-tune the file selection with the dozens of parameters described in

man find

(e.g., replace only in HTML files: -name \*.html)

This solution will try to attempt the replacement in all files. You can filter that through grep before, but that is just doing twice the work for no gain.

By the way: sed uses almost the same syntax for regular expressions as Vim (stemming from the same history).

Answer 3

If you really want to do it in Vim you can follow the suggestions here.

Answer 4

You could open all the files and type

:bufdo :s/stringiwanttoreplace/newstring/g

It performs the search/replace in all your buffers.

Answer 5

You don't need vim to do this, you can use command line tools. Using sed in a loop on the list of files to do this for you automatically. Something like this:

for each in `grep -l "stringiwanttoreplace" *` ;
do
    cat $each | sed -e "s/stringiwanttoreplace/newstring/g" > $each
; done

Answer 6

vim7 has recursive grep built-in

:vimgrep /pattern/[j][g] file file1 file2 ... fileN

the result will be shown in a quickfix-window (:help quickfix)

to do the search recursively use the **-wildcard like

**/*.c to search through the current folder and recursively through all subdirectories.