Description

Shortcuts to "grep all open buffers" (open files), and search & replace on the results or the open files themselves.

Why?

• Searching takes too long?
• Maybe you're using a huge repo or fighting a slow connection?
• Vim search/replacing confusing?
• Using an old vim or fanciest plugins have errors?
• Want a few maps named to help you memorize the plain vim commands so you don't need any plugin?

When searching and replacing files takes too long (even when using rg), this plugin helps you search through only the files you have open.

Quick Instructions

Search Opened Files / Show Quickfix Window	Mapping	Note
Search buffers for the last thing you searched for	<leader>gbufs	/ to search in page
Search buffers for whatever is under the cursor †	<leader>gbufc	Additional install
Highlight, search page, then search buffers †	<leader>gbufs	Additional install

Search And Replace Multiple Files, use Macro q	Mapping	Macro	Best For
Search And Replace all loaded files	<leader>gbufq	qq:%s/OLD/NEW/g<ENTER>q	convenience - no QF needed
Search/Replace QuickFix files, full page	<leader>bigq	qq:%s/OLD/NEW/g<ENTER>q	big files/lots of results
Search/Replace QuickFix files, line-by-line	<leader>finish	qq:s//NEW/g<ENTER>q	previewing a lot

Basic Universal Instructions

1. load files in buffers
2. load files in a quickfix list (optional)
3. make a macro labelled q (eg qq:%s/OLD/NEW/gENTERq)
4. \gbufq to run the macro on all the files

There's more workflows, but these 3 are the most common I've found.

Example of the finish Workflow

In this video:

1. Load a bunch of files into vim buffers using pattern: vim $( find . ) (rg is recommended instead of find)
2. Search for get_, don't find it in first file.
3. Search all open buffers using \gbufs. Results are displayed in the QuickFix screen.
4. Record macro qq:s//set_/gjq

• qq - record macro named q
• : - vim command mode
• s//set_/g - it's empty, so search for last search term (get_), replace with set_, globally for each line
• q - stop macro recording

5. n around, @q, then @@ to try the macro on different pages.
6. \finish to run the macro on all results found.

Table of Contents

1. Installation
2. Prerequisites
3. Learn real vim
4. Long Instructions for Workflow - finish
5. More Workflows
   1. Simple search and view results - gbufs
   2. A lot of searching/replacing of big files - bigq
6. Recommended Plugins instead of gbufs
7. Recommended Plugins/Additions complimentary to gbufs

Installation

~/.vimrc, just the most basic

Plug 'marcopolo4k/vim-gbufs'
nnoremap <leader>gbufs :call BufdoVimgrepaddCopen()
nnoremap <leader>gbufq :MacroRplceBuffersWithQEntireFile <cr>
nnoremap <leader>bigq :MacroReplaceQuickFixWithQEntireFile<cr>
nnoremap <leader>finish :MacroRplceQckFxWithQOneLine <cr>

Full vimrc: more aliases, functionality, and comment explanations:

Plug 'marcopolo4k/vim-gbufs'

" ************** Gbufs - Searching **************
"
" Search all open buffers -- for the last thing you search for --
"  Maybe your last search has word boundaries, or not. Check with '/↑'
nnoremap <leader>gbufs :call BufdoVimgrepaddCopen()
" 2nd option: Search and then open them all in horizontal window panes
nnoremap <leader>gbufa :call BufdoVimgrepaddCopenAndOpenThemAll()
" 3rd option: Type out a specific search term by command line
"   :Gbufs SEARCH_TERM
" to learn real vim, this helps to memorize
nnoremap <leader>bufdovimgrep :call BufdoVimgrepaddCopen()

" Search all open buffers -- for what's under the cursor --
"  No word boundaries default, depending on your config
"  Requires either VSetSearch or SearchParty †‡
"  Loads search result files into Quickfix List
"  Does NOT save the search in last search reg
nnoremap <leader>gbufc :call GrepBuffersForWordOnCursor("<C-R><C-W>")<CR>

" *** Gbufs - Search And Replace with Macro Q ***
"         Multiple Files at a time
"
" Replace in all buffers (does NOT use QuickFix list)
" [g]rep [buf]fers and replace with full-page macro [q]
nnoremap <leader>gbufq :MacroRplceBuffersWithQEntireFile <cr>
" to learn real vim, this helps to memorize
nnoremap <leader>bufdoq :MacroRplceBuffersWithQEntireFile<cr>

" cfdo - Macro Replace with Q - The QuickFix List - entire file at a time
"  Runs fastest on large files
"   since QF list should have less files than Buffer List
"  Macro requires '%' to search entire file at a time
"  qq:%s/OLD/NEW/gENTERq
"
nnoremap <leader>bigq :MacroReplaceQuickFixWithQEntireFile<cr>
" to learn real vim, this helps to memorize
nnoremap <leader>cfdoq :MacroReplaceQuickFixWithQEntireFile<cr>

" cdo - Macro Replace with Q - The QuickFix List - one line at a time
"  macro q does NOT need the % in ':%s/TERM/REPLACE/g'
"  macro q DOES need the TERM in ':s/TERM/REPLACE/g'
"  This makes for the easiest previewing using '/'
"
" if already previewed a bunch of changes, just need to [finish]
nnoremap <leader>finish :MacroRplceQckFxWithQOneLine <cr>
" to learn real vim, this helps to memorize
nnoremap <leader>cdoq :MacroRplceQckFxWithQOneLine <cr>

HIGHLY RECOMMENDED additions for quicker searching:

†‡ EITHER Install Plugin OR add a function to ~/.vimrc, choose one of these two:

• VSetSearch, see this stack convo
• Plug dahu/SearchParty (choose option 2 for the global var)

Prerequisites

• To do multi-file search/replacing in vim, you need to understand buffers, and preferably the quickfix window.
• See those highly recommended additions at the end of the installation section, those might almost be considered prereqs.

Learn real vim

If you want to stop using this plugin, you can start with these mappings to help memorize the commands. It's just a lot of typing, and what do we think of unnecessary typing?

Search And Replace Multiple Files	Mapping	Macro	Best For
Search And Replace all loaded files	<leader>bufdoq	qq:%s/OLD/NEW/g<ENTER>q	Convenience - the QuickFix
:bufdo execute "normal! @q" | w	(AKA gbufq)		list is not needed
Search/Replace QuickFix files, full page	<leader>cfdoq	qq:%s/OLD/NEW/g<ENTER>q	Big Files - because it runs only
:cfdo execute "normal! @q" | w	(AKA bigq)		once per file found in QF list
Search/Replace QuickFix files, line-by-line	<leader>cdoq	qq:s//NEW/g<ENTER>q	Previewing a lot - use n and
:cdo execute "normal! @q" | w	(AKA finish)		@@ to test before doing all files
Argdo runs on the original open file list	no macro yet	author of gbufs is lazy and	?
:argdo execute "normal! @q" | w		hasn't needed this one yet

Long Instructions for finish Workflow: Search and Preview a lot before replacing on all the files

1. Load files in buffers.

   Choose one of:

   • Inside vim, :grep SEARCHTERM populates the quickfix list. Downside is that it may take some time (seconds of your life!), especially if you don't use ripgrep.
   • Before starting vim, shell tools help load files. These do NOT populate the quickfix list. Couple examples:
     • a repo search: vim $( rg -l SEARCHTERM )
     • all the files in current folder: vim $( \ls )

2. Populate the quickfix list (skip this step if you already loaded the exact files you want with :grep SEARCHTERM)

   Choose one of:

   • :Gbufs SEARCHTERM
   • search with /, then \gbufs †
   • cursor on word, then \gbufc ‡

3. Make a macro labelled q (qq:s/OLD/NEW/g<ENTER>q) cdo doesn't need a % b/c it'll search each line individually

4. The effects can be seen, file by file if desired, with vim commands: @q :n / etc

   1. Search on a single buffer with /, hit n a few times to look around.
   2. Unless it exists, make macro q, like qq:s//NEW/g<ENTER>j
      • OLD is left empty since the last search is used by default.
      • j goes to next line, in the interest of step v.
   3. Run @q to replace the line you're looking at.
   4. n to find the next result, @@ to run macro on that.
   5. :n to see the next page. Or better, use quickfix list to see all results. Repeat steps i & iii.
   6. Maybe look around your buffer list if there's any file that might be different.

5. When happy, run the macro on the rest of the files: <leader>finish

†‡ Both these 2 alternatives require either one of two additional installations

See additional installation instructions †‡

† Alternative 1:

1. Highlight some text (v, then move cursor around everything to search for)
2. *
3. <leader>gbufs

• This does NOT add word boundaries in the search.

• pro: Allows for full punctuation, eg around variables, sets of words and symbols, etc

• pro: Faster to run the search.

• con: Slower to select what you want & start searching.

‡ Alternative 2

1. Put cursor on the word to search
2. * to auto-search
3. <leader>gbufs

• This opens the Quickfix window

• This adds word boundaries around the word, like: \<SEARCHTERM\>

• pro: Faster to start searching.

• con: Slower to run the search.

More Workflows

Simple search and view results - gbufs

Just searching and seeing something you might want to replace is common. If you're not ready to replace anything, it's fastest to search for the word without word boundaries. I use the default \ for my leader key.

1. ve visual highlight from beginning to end of word, then *. †
2. \gbufs to search current buffers for the term, it opens the Quickfix window.
3. Use window pane navigation to go to different files and see the usage.

A lot of searching/replacing of big files - bigq

Sometimes files are big or there's lots of results on each page, and you need the search itself to be fast. Instead of line by line, this searches each file in the Quickfix list, just once with one macro q (vs finish that executes the macro on every occurrance).

1. Load buffers, let's choose vim $( rg -l SEARCHTERM ), with optional use of rg to preview which files you're getting. (rg is ripgrep)
2. Record macro: qq:%s/SEARCH/REPLACE/gq
3. /SEARCH on the first page, then preview the change: @q, then n and @@ for more on the first page.
4. Load Quickfix list, let's choose \gbufs
5. \bigq to search/replace once on every file in the Quickfix list.

Available upon request

I could add functions to specifically open or NOT open the QuickFix preview window for any of these.

Recommended Plugins instead of gbufs

• vim-esearch is way more powerful, since gbufs is mostly just some simple maps. But I haven't been able to get esearch to work on anything but vim9 yet, so for me at least, gbufs will at least be used on old vim8 systems. gbufs might also still be preferred if you want simple maps that help you memorize the full vim commands, or just don't want larger plugins.
• If you use Neovim, gbufs works fine, but there's so many search and replace plugins (besides esearch, which is supposed to work on both):
  • nvim-spectre
  • telescope
  • muren
  • replacer

Recommended Plugins/Additions complimentary to gbufs

• custom window navigation mappings in general
• ripgrep
• dahu/SearchParty - practically a requirement for gbufs, either this or VSetSearch
• vim-abolish - :%Subvert/facility/building/g gives a bunch of capitalization variations
• Subversive - for single-page search & replace, I have a bunch of mapping for that I almost put here. (I could add available upon request)
• FZF vim plugin
• Credit for searching - fandom.com-Search_on_all_opened_buffers