git-clang-format: Add new --staged option.

[lodato]

Summary

This new mode, which requires --diff, operates very similarly to the two <commit> mode, except that the stage is formatted instead of the second commit.

The main intent of this feature is to use in pre-commit hooks so that you can ensure that all commits are properly formatted. Without this, the commit hook would have to format the working directory which is not necessarily what will be committed.

This mode requires --diff because otherwise there would be no place for the update to be written to: writing to the index would blow away changes, and writing to the working directory would be incorrect in case the working directory differs from the index.

Note: this patch was forked from D15465.

Testing of all three modes:

# setup
$ mkdir tmp
$ cd tmp
$ git init
$ cat > foo.cc
int main() {
  int x =  1;
  return 0;
}
EOF
$ git add foo.cc
$ git commit -m 'initial commit'
$ rm foo.cc
$ cat > foo.cc
int main() {
  int x =  1;
  int y =  2;
  int z =  3;
  return 0;
}
EOF
$ git add foo.cc
$ git commit -m 'commit 2'
$ sed -i -e 's/1;/10;/' foo.cc
$ git add foo.cc
$ sed -i -e 's/10;/1;/' foo.cc
$ sed -i -e 's/3;/30;/' foo.cc

$ git-clang-format --diff
diff --git a/foo.cc b/foo.cc
index cb2dbc9..2e1b0e1 100644
--- a/foo.cc
+++ b/foo.cc
@@ -1,6 +1,6 @@
 int main() {
   int x =  1;
   int y =  2;
-  int z =  30;
+  int z = 30;
   return 0;
 }
$ git-clang-format --diff --staged
diff --git a/foo.cc b/foo.cc
index 3ea8c6c..7da0033 100644
--- a/foo.cc
+++ b/foo.cc
@@ -1,5 +1,5 @@
 int main() {
-  int x =  10;
+  int x = 10;
   int y =  2;
   int z =  3;
   return 0;
$ git-clang-format --diff HEAD~ HEAD
diff --git a/foo.cc b/foo.cc
index 7bfdb83..ce6f65e 100644
--- a/foo.cc
+++ b/foo.cc
@@ -1,6 +1,6 @@
 int main() {
   int x =  1;
-  int y =  2;
-  int z =  3;
+  int y = 2;
+  int z = 3;
   return 0;
 }

[klimek]

lg

[lodato]

Update after change to D41145 that fixed len(commits) > 2 case.

google3/third_party/llvm/llvm/tools/clang/tools/clang-format/git-clang-format

 import collections
 import contextlib
 import errno
 import os
 import re
 import subprocess
 import sys
 
-usage = 'git clang-format [OPTIONS] [<commit>] [<commit>] [--] [<file>...]'
+usage = ('git clang-format [OPTIONS] [<commit>] [<commit>|--staged] '
+         '[--] [<file>...]')
 
 desc = '''
-Run clang-format on all modified lines in the working directory or in a given
-commit.
+Run clang-format on all modified lines in the working directory, in a given
+commit, or in the stage/index.
 
 Forms:
 
     git clang-format [<commit>]
         Run clang-format on all lines in the working directory that differ from
         <commit>, which defaults to HEAD. Changes are written in-place.
 
     git clang-format [<commit>] --diff
         Same as first form, but print the diff instead of writing changes
         in-place.
 
     git clang-format [<commit>] --patch
         Same as first form, but interactively choose hunks to apply, a la `git
         add -p`.
 
     git clang-format <commit1> <commit2> --diff
         Run clang-format on all lines in <commit2> that differ from <commit1>.
         Requires --diff.
 
+    git clang-format [<commit>] --staged --diff
+        Run clang-format on all lines in the git stage/index that differ from
+        <commit>, which defaults to HEAD. Requires --diff.
+
 In all of the forms above, <file>... can be used to limit what files are
 affected, using the same syntax as `git diff`. Use `--` to disambiguate between
 files and commits.
 
 The following git-config settings set the default of the corresponding option:
   clangFormat.binary
   clangFormat.commit
   clangFormat.extension
p.add_argument('--extensions',
                  help=('comma-separated list of file extensions to format, '
                        'excluding the period and case-insensitive')),
   p.add_argument('-f', '--force', action='store_true',
                  help='allow changes to unstaged files')
   p.add_argument('-p', '--patch', action='store_true',
                  help='select hunks interactively')
   p.add_argument('-q', '--quiet', action='count', default=0,
                  help='print less information')
+  p.add_argument('--staged', '--cached', action='store_true',
+                 help='format lines in the stage instead of the working dir')
   p.add_argument('--style',
                  default=config.get('clangformat.style', None),
                  help='passed to clang-format'),
   p.add_argument('-v', '--verbose', action='count', default=0,
                  help='print extra information')
   # We gather all the remaining positional arguments into 'args' since we need
   # to use some heuristics to determine whether or not <commit> was present.
   # However, to print pretty messages, we make use of metavar and help.
   p.add_argument('args', nargs='*', metavar='<commit>',
                  help='revision from which to compute the diff')
   p.add_argument('ignored', nargs='*', metavar='<file>...',
                  help='if specified, only consider differences in these files')
   opts = p.parse_args(argv)
 
   opts.verbose -= opts.quiet
   del opts.quiet
 
   source, dest, files = interpret_args(opts.args, dash_dash,
-                                       default_commit=opts.commit)
+                                       default_commit=opts.commit,
+                                       staged=opts.staged)
+  if isinstance(dest, Stage) and not opts.diff:
+    die('--diff is required when --staged is used')
   if isinstance(dest, Revision) and not opts.diff:
     die('--diff is required when two commits are given')
   changed_lines = dest.compute_diff_from(source, files)
   if opts.verbose >= 1:
     ignored_files = set(changed_lines)
   filter_by_extension(changed_lines, opts.extensions.lower().split(','))
   if opts.verbose >= 1:
     ignored_files.difference_update(changed_lines)
for entry in run('git', 'config', '--list', '--null').split('\0'):
     if entry:
       name, value = entry.split('\n', 1)
       if name in non_string_options:
         value = run('git', 'config', non_string_options[name], name)
       out[name] = value
   return out
 
 
-def interpret_args(args, dash_dash, default_commit):
+def interpret_args(args, dash_dash, default_commit, staged):
   """Interpret `args` as "[commits] [--] [files]" and return (src, dest, files).
 
   It is assumed that "--" and everything that follows has been removed from
   args and placed in `dash_dash`.
 
   If "--" is present (i.e., `dash_dash` is non-empty), the arguments to its
   left (if present) are taken as commits.  Otherwise, the arguments are checked
   from left to right if they are commits or files.  If commits are not given,
def interpret_args(args, dash_dash, default_commit, staged):
   else:
     commits = [default_commit]
     files = []
 
   assert len(commits) != 0
   if len(commits) > 2:
     die('at most two commits allowed; %d given' % len(commits))
   elif len(commits) == 2:
+    if staged:
+      die('--staged is not allowed when two commits are given')
     return Revision(commits[0]), Revision(commits[1]), files
+  elif staged:
+    return Revision(commits[0]), Stage(), files
   else:
     return Revision(commits[0]), Workdir(), files
 
 
 def disambiguate_revision(value):
   """Returns True if `value` is a revision, False if it is a file, or dies."""
   # If `value` is ambiguous (neither a commit nor a file), the following
   # command will die with an appropriate error message.
def get_object_type(value):
   p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   stdout, stderr = p.communicate()
   if p.returncode != 0:
     return None
   return convert_string(stdout.strip())
 
 
 class TreeLocation (object):
-  """Represents either a commit or the working directory.
+  """Represents either a commit, the stage, or the working directory.
 
   Do not use this directly. Instead, use one of the subclasses."""
 
   def compute_diff_from(self, source, files):
     """Return diff from `source` to `self`.
 
     Return value is dictionary mapping filename to list of (start_line,
     line_count) pairs."""
def _file_mode(self, filename):
     return os.stat(filename).st_mode
 
   def _compute_diff_from_base_command(self, source):
     return ['git', 'diff-index', '-p', '-U0', source.revision]
 
   is_workdir = True
 
 
+class Stage (TreeLocation):
+  """Represents the git stage, a.k.a. the index."""
+
+  def create_tree(self, unused_filenames):
+    return run('git', 'write-tree')
+
+  def _file_mode(self, filename):
+    stdout = run('git', 'ls-files', '--stage', filename)
+    # note: there is an optional <tag> as the first element.
+    return int(stdout.split()[-4], 8)
+
+  def _compute_diff_from_base_command(self, source):
+    return ['git', 'diff-index', '-p', '-U0', '--cached', source.revision]
+
+  def _blob_name(self, filename):
+    return ':%s' % filename
+
+
 class Revision (TreeLocation):
   """Represents a specific revision, a.k.a. a commit."""
 
   def __init__(self, revision):
     self.revision = revision
 
   def create_tree(self, unused_filenames):
     return self.revision