Add new 'auto_format_git_diff' behavior

When you edit a file tracked in git, it may happend that some tracked
lines are not well formatted. If you modify this file, and you
auto_format the file, lines with bad indentation will be formatted too.
You will be end up with unrelated changes in your commit.

It may even appear that these 'bad formatted lines' were indented like
this with a purpose.

To mitigate this issue, this commit proposes to only format diff'ed
lines in a file. It roughly relies on git diff, and on clang-format
'-lines' option.

clang_format#format function has been modified to accept a list of
ranges.

It adds three new user options:
- g:clang_format#auto_format_git_diff to enable this new behavior
- g:clang_format#auto_format_git_diff_fallback to decide what to do in
  case of untracked file
- g:clang_format#git to define non standard git path or options

Author: jreybert

autoload/clang_format.vim

@@ -139,6 +139,14 @@ function! clang_format#is_invalid() abort
         let s:version = v
     endif
 
+    if g:clang_format#auto_format_git_diff &&
+                \ !exists('s:git_available')
+        if !executable(g:clang_format#git)
+            return 1
+        endif
+        let s:git_available = 1
+    endif
+
     return 0
 endfunction
 
@@ -184,6 +192,7 @@ let g:clang_format#extra_args = s:getg('clang_format#extra_args', "")
 if type(g:clang_format#extra_args) == type([])
     let g:clang_format#extra_args = join(g:clang_format#extra_args, " ")
 endif
+let g:clang_format#git = s:getg('clang_format#git', 'git')
 
 let g:clang_format#code_style = s:getg('clang_format#code_style', 'google')
 let g:clang_format#style_options = s:getg('clang_format#style_options', {})
@@ -193,6 +202,8 @@ let g:clang_format#detect_style_file = s:getg('clang_format#detect_style_file',
 let g:clang_format#enable_fallback_style = s:getg('clang_format#enable_fallback_style', 1)
 
 let g:clang_format#auto_format = s:getg('clang_format#auto_format', 0)
+let g:clang_format#auto_format_git_diff = s:getg('clang_format#auto_format_git_diff', 0)
+let g:clang_format#auto_format_git_diff_fallback = s:getg('clang_format#auto_format_git_diff_fallback', 'file')
 let g:clang_format#auto_format_on_insert_leave = s:getg('clang_format#auto_format_on_insert_leave', 0)
 let g:clang_format#auto_formatexpr = s:getg('clang_format#auto_formatexpr', 0)
 " }}}
@@ -203,8 +214,13 @@ function! s:detect_style_file() abort
     return findfile('.clang-format', dirname.';') != '' || findfile('_clang-format', dirname.';') != ''
 endfunction
 
-function! clang_format#format(line1, line2) abort
-    let args = printf(' -lines=%d:%d', a:line1, a:line2)
+" clang_format#format_ranges is were the magic happends.
+" ranges is a list of pairs, like [[start1,end1],[start2,end2]...]
+function! clang_format#format_ranges(ranges) abort
+    let args = ''
+    for range in a:ranges
+        let args .= printf(' -lines=%d:%d', range[0], range[1])
+    endfor
     if ! (g:clang_format#detect_style_file && s:detect_style_file())
         if g:clang_format#enable_fallback_style
             let args .= ' ' . s:shellescape(printf('-style=%s', s:make_style_options())) . ' '
@@ -223,14 +239,18 @@ function! clang_format#format(line1, line2) abort
     let source = join(getline(1, '$'), "\n")
     return s:system(clang_format, source)
 endfunction
+
+function! clang_format#format(line1, line2) abort
+    return clang_format#format_ranges([[line1, line2]])
+endfunction
 " }}}
 
 " replace buffer {{{
-function! clang_format#replace(line1, line2, ...) abort
+function! clang_format#replace_ranges(ranges, ...) abort
     call s:verify_command()
 
     let pos_save = a:0 >= 1 ? a:1 : getpos('.')
-    let formatted = clang_format#format(a:line1, a:line2)
+    let formatted = clang_format#format_ranges(a:ranges)
     if !s:success(formatted)
         call s:error_message(formatted)
         return
@@ -247,6 +267,10 @@ function! clang_format#replace(line1, line2, ...) abort
     call winrestview(winview)
     call setpos('.', pos_save)
 endfunction
+
+function! clang_format#replace(line1, line2, ...) abort
+    call call(function("clang_format#replace_ranges"), [[line1, line2]], a:000)
+endfunction
 " }}}
 
 " auto formatting on insert leave {{{
@@ -291,6 +315,91 @@ endfunction
 function! clang_format#disable_auto_format() abort
     let g:clang_format#auto_format = 0
 endfunction
+
+" s:strip: helper function to strip a string
+function! s:strip(string)
+    return substitute(a:string, '^\s*\(.\{-}\)\s*\r\=\n\=$', '\1', '')
+endfunction
+
+" clang_format#get_git_diff
+" a:file must be an absolute path to the file to be processed
+" this function compares the current buffer content against the
+" git index content of the file.
+" this function returns a list of pair of ranges if the file is tracked
+" and has changes, an empty list otherwise
+function! clang_format#get_git_diff(cur_file)
+    let file_path = isdirectory(a:cur_file) ? a:cur_file :
+                \ fnamemodify(a:cur_file, ":h")
+    let top_dir=s:strip(system(
+                \ g:clang_format#git." -C ".shellescape(file_path).
+                \ " rev-parse --show-toplevel"))
+    if v:shell_error != 0
+        return []
+    endif
+    let cur_file = s:strip(s:system(
+                \ g:clang_format#git." -C ".shellescape(top_dir).
+                \ " ls-files --error-unmatch ".shellescape(a:cur_file)))
+    if v:shell_error != 0
+        return []
+    endif
+    let source = join(getline(1, '$'), "\n")
+    " git show :file shows the staged content of the file:
+    "  - content in index if any (staged but not commmited)
+    "  - else content in HEAD
+    " this solution also solves the problem for 'git mv'ed file:
+    "  - if the current buffer has been renamed by simple mv (without git
+    "    add), the file is considered as untracked
+    "  - if the renamed file has been git added or git mv, git show :file
+    "    will show the expected content.
+    " this barbarian command does the following:
+    "  - diff --*-group-* options will return ranges (start,end) for each
+    "    diff chunk
+    "  - <(git show :file) is a process substitution, using /dev/fd/<n> as
+    "    temporary file for the output
+    "  - - is stdin, which is current buffer content in variable 'source'
+    let diff_cmd =
+            \ 'diff <('.g:clang_format#git.' show :'.shellescape(cur_file).') - '.
+            \ '--old-group-format="" --unchanged-group-format="" '.
+            \ '--new-group-format="%dF-%dL%c''\\012''" '.
+            \ '--changed-group-format="%dF-%dL%c''\\012''"'
+    let ranges = s:system(diff_cmd, source)
+    if !(v:shell_error == 0 || v:shell_error == 1)
+        throw printf("clang-format: git diff failed `%s` for ranges %s",
+                    \ diff_cmd, ranges)
+    endif
+    let ranges = split(ranges, '\n')
+    " ranges is now a list of pairs [[start1, end1],[start2,end2]...]
+    let ranges = map(ranges, "split(v:val, '-')")
+    return ranges
+endfunction
+
+" this function will try to format only buffer lines diffing from git index
+" content.
+" If the file is untracked (not in a git repo or not tracked in a git repo),
+" it returns 1.
+" If the format succeeds, it returns 0.
+function! clang_format#do_auto_format_git_diff()
+    let cur_file = expand("%:p")
+    let ranges = clang_format#get_git_diff(cur_file)
+    if !empty(ranges)
+        call clang_format#replace_ranges(ranges)
+        return 0
+    else
+        return 1
+    endif
+endfunction
+
+function! clang_format#do_auto_format()
+    if g:clang_format#auto_format_git_diff
+        let ret = clang_format#do_auto_format_git_diff()
+        if ret == 0 ||
+           \ g:clang_format#auto_format_git_diff_fallback != 'file'
+            return
+        endif
+    endif
+    call clang_format#replace_ranges([[1, line('$')]])
+endfunction
+
 " }}}
 let &cpo = s:save_cpo
 unlet s:save_cpo

doc/clang-format.txt

@@ -127,6 +127,11 @@ g:clang_format#command                                  *g:clang_format#command*
     Name of clang-format command.
     The default value is "clang-format".
 
+g:clang_format#git                                          *g:clang_format#git*
+
+    Name of the git command.
+    The default value is "git".
+
 g:clang_format#code_style                            *g:clang_format#code_style*
 
     Base coding style for formatting.  Available coding styles are "llvm",
@@ -186,6 +191,25 @@ g:clang_format#auto_format                          *g:clang_format#auto_format*
     buffer on saving the buffer.  Formatting is executed at |BufWritePre| event.
     The default value is 0.
 
+g:clang_format#auto_format_git_diff        *g:clang_format#auto_format_git_diff*
+
+    When this value is 1, and when g:clang_format#auto_format is 1, the auto
+    format only formats modified lines is the file is tracked in git.
+    If the file is not tracked, or even not in a git project, fallback
+    behavior depends on |g:clang_format#auto_format_git_diff_fallback|.
+    WARNING: this option should not be used with
+    |g:clang_format#auto_format_on_insert_leave|.
+    The default value is 0.
+
+g:clang_format#auto_format_git_diff_fallback
+                                  *g:clang_format#auto_format_git_diff_fallback*
+
+    Fallback behavior when |g:clang_format#auto_format_git_diff| is 1 and the
+    current file is not tracked. The value can be:
+    - 'file': the whole file is formatted (which is the default
+      |g:clang_format#auto_format| behavior).
+    - 'pass': the file is not formatted.
+
 g:clang_format#auto_format_on_insert_leave
                                     *g:clang_format#auto_format_on_insert_leave*
 

plugin/clang_format.vim

@@ -22,7 +22,7 @@ augroup plugin-clang-format-auto-format
         \ if &ft =~# '^\%(c\|cpp\|objc\|java\|javascript\|typescript\|proto\|arduino\)$' &&
         \     g:clang_format#auto_format &&
         \     !clang_format#is_invalid() |
-        \     call clang_format#replace(1, line('$')) |
+        \     call clang_format#do_auto_format() |
         \ endif
     autocmd FileType c,cpp,objc,java,javascript,typescript,proto,arduino
         \ if g:clang_format#auto_format_on_insert_leave &&