Added git hyper-blame, a tool that skips unwanted commits in git blame.

git_common.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Monkeypatch IMapIterator so that Ctrl-C can kill everything properly.
 # Derived from https://gist.github.com/aljungberg/626518
 import multiprocessing.pool
 from multiprocessing.pool import IMapIterator
 def wrapper(func):
   def wrap(self, timeout=None):
@@ skipping 263 matching lines @@
   def _inner_gen():
     yield function()
     while True:
       yield
   return _inner_gen().next
 
 
 ## Git functions
 
 
+def blame(filename, revision=None, porcelain=False, *args):
+  command = ['blame']
+  if porcelain:  # pragma: no cover

[iannucci, 2016/01/29 19:29:25]

why not covered?

[Matt Giuca, 2016/02/01 03:51:06]

Testing porcelain was a lot of work, and covered implicitly by hyper-blame
tests.

Well, I've added porcelain tests.

+    command.append('-p')
+  if revision is not None:
+    command.append(revision)

[iannucci, 2016/01/29 19:29:25]

may want to consider -w and -M options

[Matt Giuca, 2016/02/01 03:51:06]

I think we could consider that in a future version. I don't think we want that
to be the default for hyper-blame (which has the specific goal of ignoring
certain commits, not necessarily bypassing other arbitrary changes).

+  command.extend(['--', filename])
+  return run(*command)
+
+
 def branch_config(branch, option, default=None):
   return config('branch.%s.%s' % (branch, option), default=default)
 
 
 def config_regexp(pattern):
   if IS_WIN: # pragma: no cover
     # this madness is because we call git.bat which calls git.exe which calls
     # bash.exe (or something to that effect). Each layer divides the number of
     # ^'s by 2.
     pattern = pattern.replace('^', '^' * 8)
@@ skipping 245 matching lines @@
     if abort:
       run_with_retcode('rebase', '--abort')  # ignore failure
     return RebaseRet(False, cpe.stdout, cpe.stderr)
 
 
 def remove_merge_base(branch):
   del_branch_config(branch, 'base')
   del_branch_config(branch, 'base-upstream')
 
 
+def repo_root():  # pragma: no cover

[iannucci, 2016/01/29 19:29:25]

?

[Matt Giuca, 2016/02/01 03:51:06]

I didn't think it would be easy to test this since it's in a random directory.
But it was kind of easy. Done.

+  """Returns the absolute path to the repository root."""
+  return run('rev-parse', '--show-toplevel')
+
+
 def root():
   return config('depot-tools.upstream', 'origin/master')
 
 
+@contextlib.contextmanager
+def less():  # pragma: no cover
+  """Runs 'less' as context manager yielding its stdin as a PIPE.
+
+  Automatically checks if sys.stdout is a non-TTY stream. If so, it avoids
+  running less and just yields sys.stdout.
+  """

[iannucci, 2016/01/29 19:29:25]

does this work on windows?

Generally stuff in depot_tools at least tries to work in windows too... I would
at least try to make linux features gracefully degrade. If running it with `git
bash` is sufficient, I would detect a non-bash environment, print an error to
that effect and exit.

[Matt Giuca, 2016/02/01 03:51:06]

Tested on Windows; works perfectly, except for an IOError if you quit less
before getting to the end. Added a catch for that.

Tested on both MinGW and cmd, for both regular terminal output and piping to a
file. I'm a bit surprised that less worked from cmd, given that typing "less"
doesn't work on the command line. But it seems to be fine.

Tests almost completely fail, but that's also true of git_common_test so I think
there is just something bad about the testing environment on Windows and
probably not worth looking into.

+  if not sys.stdout.isatty():
+    yield sys.stdout
+    return
+
+  # Run with the same options that git uses (see setup_pager in git repo).
+  # -F: Automatically quit if the output is less than one screen.
+  # -R: Don't escape ANSI color codes.
+  # -X: Don't clear the screen before starting.
+  cmd = ('less', '-FRX')
+  try:
+    proc = subprocess2.Popen(cmd, stdin=subprocess2.PIPE)
+    yield proc.stdin
+  finally:
+    proc.stdin.close()
+    proc.wait()
+
+
 def run(*cmd, **kwargs):
   """The same as run_with_stderr, except it only returns stdout."""
   return run_with_stderr(*cmd, **kwargs)[0]
 
 
 def run_with_retcode(*cmd, **kwargs):
   """Run a command but only return the status code."""
   try:
     run(*cmd, **kwargs)
     return 0
@@ skipping 297 matching lines @@
                       ['HEAD'])
 
 
 def clone_file(repository, new_workdir, link, operation):
   if not os.path.exists(os.path.join(repository, link)):
     return
   link_dir = os.path.dirname(os.path.join(new_workdir, link))
   if not os.path.exists(link_dir):
     os.makedirs(link_dir)
   operation(os.path.join(repository, link), os.path.join(new_workdir, link))