Best way to load arbitrary git command output into the quickfix/location list

[vyasr]

I have some pre-commit hooks set up for a project. When I need to act on the hook diagnostics from a commit, I dump the results to either the preview window (with Git! commit ...) or a temp file (with Git -p commit...). To facilitate stepping through the errors, I run either of the above commands and then execute [l|c]file % in the preview window/temp file to load the results into the quickfix/location list. Is there a built-in way of doing this like Git -q -p commit... analogous to Ggrep -q?

Thanks for building such a great plugin!

[tpope]

There's no built-in way to route Git output directly into the quickfix list. I've thought about adding it but it seems extremely unhelpful to do so with the default value of 'errorformat'. For the niches where it's helpful, your 2 step solution gets the job done.

But in terms of solving your actual problem, you can do that much more elegantly by tapping into the FugitiveChanged event, which triggers on every :Git call. Here's an example that operates on the whitespace error checking provided by pre-commit.sample:

function! s:AfterGit() abort
  if !exists('*FugitiveResult')
    return
  endif
  let result = FugitiveResult()
  if !filereadable(get(result, 'file', '')) || get(result.args, 0, '') !=# 'commit' || !get(result, 'exit_status')
    return
  endif
  let args = result.args[0 : index(result.args, '--')]
  let root = FugitiveWorkTree(result) . '/'
  let list = []
  let valid = 0
  for line in readfile(result.file)
    let match = matchlist(line, '\v^([^:]*):(\d+): *(.*)')
    if len(match) && filereadable(root . match[1])
      let valid = 1
      if index(args, '-a') >= 0 || index(args, '--all') >= 0
        call add(list, {'filename': FugitiveFind(':(top)' . match[1], result), 'lnum': +match[2], 'text': match[3], 'valid': 1})
      else
        let module = ':0:' . match[1]
        call add(list, {'filename': FugitiveFind(module, result), 'module': module, 'lnum': +match[2], 'text': match[3], 'valid': 1})
      endif
    else
      call add(list, {'text': line})
    endif
  endfor
  if valid
    call setqflist(list)
    let winnr = winnr()
    silent botright copen
    if winnr != winnr()
      exe winnr . 'wincmd w'
    endif
  endif
endfunction

augroup gitprecommit
  autocmd!
  autocmd User FugitiveChanged call s:AfterGit()
augroup END

This one goes to a great deal of trouble to try to account for if changes are in the index and work tree; if you're running a test suite you don't need to do that. Rough take on a cgetfile version:

function! s:AfterGit() abort
  if !exists('*FugitiveResult')
    return
  endif
  let result = FugitiveResult()
  if !filereadable(get(result, 'file', '')) || get(result.args, 0, '') !=# 'commit' || !get(result, 'exit_status')
    return
  endif
  exe 'cgetfile' fnameescape(result.file)
endfunction

[vyasr]

Nice! That is indeed a much more elegant solution. I see your point about not offering this kind of support out of the box, without a way to intelligently parse the errors you're right that in most cases the quickfix list ends up filled with a lot of extra junk. In your first example, would it be possible to simplify this further using something like:

let old_errorformat=&errorformat
set errorformat=...
getqflist(pre_commit_output)  " This should use the new errorformat
set errorformat=old_errorformat

I'm basically wondering if we could leverage the existing logic for errorformat parsing rather than rewriting the regex parsing. I suppose it doesn't really simplify the logic around handling the git index files, though, and I don't know if it's a best practice to modify the errorformat temporarily in this way.

[tpope]

Not only does it not simply the logic around handling the git index files, it makes doing so impossible, as you can't call a function like FugitiveFind() from 'errorformat'. If you do want to use 'errorformat', you can use cgetfile, that's why it's in the second example.

Robust example of temporarily overriding 'errorformat'.

try
  let old_errorformat = &l:errorformat
  setlocal errorformat=...
  exe 'cgetfile' fnameescape(result.file)
finally
  let &l:errorformat = old_errorformat
endtry

[tpope]

Recent versions of Vim support passing an efm option directly to setqflist(). See :help setqflist().

[vyasr]

Got it, thanks.