Filter specific lines matching a pattern through external command

Question

I'm trying to filter specific lines through external command. I think knowing how to do this would be extremely beneficial to me, so I'm trying to find a way to do this. As an example, I wanted to count the occurrence of a specific word or line in a file. I was trying to do this with a filter, using the following command: :g/http/w !wc -l

However, this ran w !wc -l for every line matching the file, so I got the total number of lines in the file, a number of times equal to the number of matches.

What I was expecting, was something akin to this line: :%!grep http | wc -l

Is something like this possible in vim using filters or commands? If not, I'm fine using the grep wc solution, but it would be nice having a clean way to do this from vim.

I've also noticed that :g/http/p prints all the matching lines, but I don't have the option of piping the output to an external command using the print command. Is there anything else I could use?

Answer 1

but I don't have the option of piping the output to an external command

Actually you do:

echo system('wc -l', execute('g/http/'))

However, note that execute() prepends a newline to the resulting string, while not appending a newline after it. Hence the result of wc -l remains the same, but it could matter under different circumstances.

Answer 2

I'm not aware of any builtin, compact functionality that let's you filter the output of any vim command through any external command. With a little one-time scripting, though, you could get something like this...

:MyFilt g/http/ | wc -l

To start, put this in your vimrc...

func! MyFilt(cmd)
    let parts = split(a:cmd, '|')
    let vimcmd = trim(parts[0])
    let shcmd = trim(parts[1])
    echom trim(system(shcmd, execute(vimcmd)))
endfunc

(The base command here is pretty much what Matt showed in his answer plus a bunch of junk trimming.)

We could use this like...

:call MyFilt('g/http/ | wc -l')

But we can distill it down further using a :command (also goes in your vimrc)...

:command -nargs=1 MyFilt call MyFilt(<f-args>)

And now your call can be of the form :MyFilt <vim-command> | <sh-filter> as show above...

:MyFilt g/http/ | wc -l

(The uniqueness of a one-arg :command's param processing is to thank here. It just takes everything after the command name and passes it as a single string param to the designated function.)

Answer 3

You can use :%s/pattern/gn The n tells it to count the g to count every occurrence.

Answer 4

Thanks to @B Layers and @Matts answers, I've written this function which serves my purposes perfectly. I'm sharing it here for future reference, if anyone needs the same functionality.

" Function to pipe output of vim command to external command.
" The 'trim' argument determines whether the vim command
" output will be trimmed before piping it to the external
" command. The 'cmd' argument is the full command, including
" the vim command. The vim command is separated from the
" external command with a '|' character, and everything from
" the first '|' character to the end of the line is considered
" the external command, so external pipes work as well.
function! Pipe(trim, cmd)
    " Split the command
    let l:cmds = split(a:cmd, '|')

    " Save the state of the number and relativenumber option
    let l:number = &number
    let l:relativenumber = &relativenumber

    " Disable the two options, so that the vim output doesn't have line numbers
    setlocal nonumber norelativenumber

    " Run the vim command
    let l:vimresult = execute(trim(l:cmds[0]))

    " Restore the two saved options
    let &l:number = l:number
    let &l:relativenumber = l:relativenumber

    " Trim the vim command if necessary
    if a:trim
        let l:vimresult = trim(l:vimresult)
    endif

    " If there was no external command, return the output of the vim command
    if len(l:cmds) <= 1
        return l:vimresult
    endif

    " Run the external command and return the output
    return trim(system(join(l:cmds[1:], '|'), l:vimresult))
endfunction

" Define a command called Pipe for calling the Pipe() function
command! -nargs=1 -bang -complete=command Pipe echo Pipe(<bang>1, <f-args>)

Using it is simple, just do this:

:Pipe[!] g/test/ | wc -l

If the bang is present, the function won't trim the vim command output, which is, for example, needed for wc to correctly output the number of lines, since it counts all the newlines found in the text.