libv8 8.4.255.0

data/vendor/depot_tools/git_find_releases.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# Copyright 2015 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.
+"""Usage: %prog <commit>*
+
+Given a commit, finds the release where it first appeared (e.g. 47.0.2500.0) as
+well as attempting to determine the branches to which it was merged.
+
+Note that it uses the "cherry picked from" annotation to find merges, so it will
+only work on merges that followed the "use cherry-pick -x" instructions.
+"""
+
+from __future__ import print_function
+
+import optparse
+import re
+import sys
+
+import git_common as git
+
+
+def GetNameForCommit(sha1):
+  name = re.sub(r'~.*$', '', git.run('name-rev', '--tags', '--name-only', sha1))
+  if name == 'undefined':
+    name = git.run(
+        'name-rev', '--refs', 'remotes/branch-heads/*', '--name-only',
+        sha1) + ' [untagged]'
+  return name
+
+
+def GetMergesForCommit(sha1):
+  return [c.split()[0] for c in
+          git.run('log', '--oneline', '-F', '--all', '--no-abbrev', '--grep',
+                  'cherry picked from commit %s' % sha1).splitlines()]
+
+
+def main(args):
+  parser = optparse.OptionParser(usage=sys.modules[__name__].__doc__)
+  _, args = parser.parse_args(args)
+
+  if len(args) == 0:
+    parser.error('Need at least one commit.')
+
+  for arg in args:
+    commit_name = GetNameForCommit(arg)
+    if not commit_name:
+      print('%s not found' % arg)
+      return 1
+    print('commit %s was:' % arg)
+    print('  initially in ' + commit_name)
+    merges = GetMergesForCommit(arg)
+    for merge in merges:
+      print('  merged to ' + GetNameForCommit(merge) + ' (as ' + merge + ')')
+    if not merges:
+      print('No merges found. If this seems wrong, be sure that you did:')
+      print('  git fetch origin && gclient sync --with_branch_heads')
+
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_footers.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+# 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.
+
+from __future__ import print_function
+
+import argparse
+import json
+import re
+import sys
+
+from collections import defaultdict
+
+import git_common as git
+
+
+FOOTER_PATTERN = re.compile(r'^\s*([\w-]+): *(.*)$')
+CHROME_COMMIT_POSITION_PATTERN = re.compile(r'^([\w/\-\.]+)@{#(\d+)}$')
+FOOTER_KEY_BLOCKLIST = set(['http', 'https'])
+
+
+def normalize_name(header):
+  return '-'.join([ word.title() for word in header.strip().split('-') ])
+
+
+def parse_footer(line):
+  """Returns footer's (key, value) if footer is valid, else None."""
+  match = FOOTER_PATTERN.match(line)
+  if match and match.group(1) not in FOOTER_KEY_BLOCKLIST:
+    return (match.group(1), match.group(2))
+  return None
+
+
+def parse_footers(message):
+  """Parses a git commit message into a multimap of footers."""
+  _, _, parsed_footers = split_footers(message)
+  footer_map = defaultdict(list)
+  if parsed_footers:
+    # Read footers from bottom to top, because latter takes precedense,
+    # and we want it to be first in the multimap value.
+    for (k, v) in reversed(parsed_footers):
+      footer_map[normalize_name(k)].append(v.strip())
+  return footer_map
+
+
+def matches_footer_key(line, key):
+  """Returns whether line is a valid footer whose key matches a given one.
+
+  Keys are compared in normalized form.
+  """
+  r = parse_footer(line)
+  if r is None:
+    return False
+  return normalize_name(r[0]) == normalize_name(key)
+
+
+def split_footers(message):
+  """Returns (non_footer_lines, footer_lines, parsed footers).
+
+  Guarantees that:
+    (non_footer_lines + footer_lines) ~= message.splitlines(), with at
+      most one new newline, if the last paragraph is text followed by footers.
+    parsed_footers is parse_footer applied on each line of footer_lines.
+      There could be fewer parsed_footers than footer lines if some lines in
+      last paragraph are malformed.
+  """
+  message_lines = list(message.splitlines())
+  footer_lines = []
+  maybe_footer_lines = []
+  for line in reversed(message_lines):
+    if line == '' or line.isspace():
+      break
+    elif parse_footer(line):
+      footer_lines.extend(maybe_footer_lines)
+      maybe_footer_lines = []
+      footer_lines.append(line)
+    else:
+      # We only want to include malformed lines if they are preceded by
+      # well-formed lines. So keep them in holding until we see a well-formed
+      # line (case above).
+      maybe_footer_lines.append(line)
+  else:
+    # The whole description was consisting of footers,
+    # which means those aren't footers.
+    footer_lines = []
+
+  footer_lines.reverse()
+  footers = [footer for footer in map(parse_footer, footer_lines) if footer]
+  if not footers:
+    return message_lines, [], []
+  if maybe_footer_lines:
+    # If some malformed lines were left over, add a newline to split them
+    # from the well-formed ones.
+    return message_lines[:-len(footer_lines)] + [''], footer_lines, footers
+  return message_lines[:-len(footer_lines)], footer_lines, footers
+
+
+def get_footer_change_id(message):
+  """Returns a list of Gerrit's ChangeId from given commit message."""
+  return parse_footers(message).get(normalize_name('Change-Id'), [])
+
+
+def add_footer_change_id(message, change_id):
+  """Returns message with Change-ID footer in it.
+
+  Assumes that Change-Id is not yet in footers, which is then inserted at
+  earliest footer line which is after all of these footers:
+    Bug|Issue|Test|Feature.
+  """
+  assert 'Change-Id' not in parse_footers(message)
+  return add_footer(message, 'Change-Id', change_id,
+                    after_keys=['Bug', 'Issue', 'Test', 'Feature'])
+
+
+def add_footer(message, key, value, after_keys=None, before_keys=None):
+  """Returns a message with given footer appended.
+
+  If after_keys and before_keys are both None (default), appends footer last.
+  If after_keys is provided and matches footers already present, inserts footer
+  as *early* as possible while still appearing after all provided keys, even
+  if doing so conflicts with before_keys.
+  If before_keys is provided, inserts footer as late as possible while still
+  appearing before all provided keys.
+
+  For example, given
+      message='Header.\n\nAdded: 2016\nBug: 123\nVerified-By: CQ'
+      after_keys=['Bug', 'Issue']
+  the new footer will be inserted between Bug and Verified-By existing footers.
+  """
+  assert key == normalize_name(key), 'Use normalized key'
+  new_footer = '%s: %s' % (key, value)
+  if not FOOTER_PATTERN.match(new_footer):
+    raise ValueError('Invalid footer %r' % new_footer)
+
+  top_lines, footer_lines, _ = split_footers(message)
+  if not footer_lines:
+    if not top_lines or top_lines[-1] != '':
+      top_lines.append('')
+    footer_lines = [new_footer]
+  else:
+    after_keys = set(map(normalize_name, after_keys or []))
+    after_indices = [
+        footer_lines.index(x) for x in footer_lines for k in after_keys
+        if matches_footer_key(x, k)]
+    before_keys = set(map(normalize_name, before_keys or []))
+    before_indices = [
+        footer_lines.index(x) for x in footer_lines for k in before_keys
+        if matches_footer_key(x, k)]
+    if after_indices:
+      # after_keys takes precedence, even if there's a conflict.
+      insert_idx = max(after_indices) + 1
+    elif before_indices:
+      insert_idx = min(before_indices)
+    else:
+      insert_idx = len(footer_lines)
+    footer_lines.insert(insert_idx, new_footer)
+  return '\n'.join(top_lines + footer_lines)
+
+
+def remove_footer(message, key):
+  """Returns a message with all instances of given footer removed."""
+  key = normalize_name(key)
+  top_lines, footer_lines, _ = split_footers(message)
+  if not footer_lines:
+    return message
+  new_footer_lines = []
+  for line in footer_lines:
+    try:
+      f = normalize_name(parse_footer(line)[0])
+      if f != key:
+        new_footer_lines.append(line)
+    except TypeError:
+      # If the footer doesn't parse (i.e. is malformed), just let it carry over.
+      new_footer_lines.append(line)
+  return '\n'.join(top_lines + new_footer_lines)
+
+
+def get_unique(footers, key):
+  key = normalize_name(key)
+  values = footers[key]
+  assert len(values) <= 1, 'Multiple %s footers' % key
+  if values:
+    return values[0]
+  else:
+    return None
+
+
+def get_position(footers):
+  """Get the commit position from the footers multimap using a heuristic.
+
+  Returns:
+    A tuple of the branch and the position on that branch. For example,
+
+    Cr-Commit-Position: refs/heads/master@{#292272}
+
+    would give the return value ('refs/heads/master', 292272).
+  """
+
+  position = get_unique(footers, 'Cr-Commit-Position')
+  if position:
+    match = CHROME_COMMIT_POSITION_PATTERN.match(position)
+    assert match, 'Invalid Cr-Commit-Position value: %s' % position
+    return (match.group(1), match.group(2))
+
+  raise ValueError('Unable to infer commit position from footers')
+
+
+def main(args):
+  parser = argparse.ArgumentParser(
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter
+  )
+  parser.add_argument('ref', nargs='?', help='Git ref to retrieve footers from.'
+                      ' Omit to parse stdin.')
+
+  g = parser.add_mutually_exclusive_group()
+  g.add_argument('--key', metavar='KEY',
+                 help='Get all values for the given footer name, one per '
+                 'line (case insensitive)')
+  g.add_argument('--position', action='store_true')
+  g.add_argument('--position-ref', action='store_true')
+  g.add_argument('--position-num', action='store_true')
+  g.add_argument('--json', help='filename to dump JSON serialized footers to.')
+
+  opts = parser.parse_args(args)
+
+  if opts.ref:
+    message = git.run('log', '-1', '--format=%B', opts.ref)
+  else:
+    message = sys.stdin.read()
+
+  footers = parse_footers(message)
+
+  if opts.key:
+    for v in footers.get(normalize_name(opts.key), []):
+      print(v)
+  elif opts.position:
+    pos = get_position(footers)
+    print('%s@{#%s}' % (pos[0], pos[1] or '?'))
+  elif opts.position_ref:
+    print(get_position(footers)[0])
+  elif opts.position_num:
+    pos = get_position(footers)
+    assert pos[1], 'No valid position for commit'
+    print(pos[1])
+  elif opts.json:
+    with open(opts.json, 'w') as f:
+      json.dump(footers, f)
+  else:
+    for k in footers.keys():
+      for v in footers[k]:
+        print('%s: %s' % (k, v))
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_freezer.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+# 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.
+
+from __future__ import print_function
+
+import sys
+import optparse
+
+import subcommand
+
+from git_common import freeze, thaw
+
+def CMDfreeze(parser, args):
+  """Freeze a branch's changes."""
+  parser.parse_args(args)
+  return freeze()
+
+
+def CMDthaw(parser, args):
+  """Returns a frozen branch to the state before it was frozen."""
+  parser.parse_args(args)
+  return thaw()
+
+
+def main(args):
+  dispatcher = subcommand.CommandDispatcher(__name__)
+  ret = dispatcher.execute(optparse.OptionParser(), args)
+  if ret:
+    print(ret)
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_hyper_blame.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python
+# Copyright 2016 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.
+
+"""Wrapper around git blame that ignores certain commits.
+"""
+
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import argparse
+import collections
+import logging
+import os
+import subprocess2
+import sys
+
+import git_common
+import git_dates
+import setup_color
+
+
+logging.getLogger().setLevel(logging.INFO)
+
+
+DEFAULT_IGNORE_FILE_NAME = '.git-blame-ignore-revs'
+
+
+class Commit(object):
+  """Info about a commit."""
+  def __init__(self, commithash):
+    self.commithash = commithash
+    self.author = None
+    self.author_mail = None
+    self.author_time = None
+    self.author_tz = None
+    self.committer = None
+    self.committer_mail = None
+    self.committer_time = None
+    self.committer_tz = None
+    self.summary = None
+    self.boundary = None
+    self.previous = None
+    self.filename = None
+
+  def __repr__(self):  # pragma: no cover
+    return '<Commit %s>' % self.commithash
+
+
+BlameLine = collections.namedtuple(
+    'BlameLine',
+    'commit context lineno_then lineno_now modified')
+
+
+def parse_blame(blameoutput):
+  """Parses the output of git blame -p into a data structure."""
+  lines = blameoutput.split('\n')
+  i = 0
+  commits = {}
+
+  while i < len(lines):
+    # Read a commit line and parse it.
+    line = lines[i]
+    i += 1
+    if not line.strip():
+      continue
+    commitline = line.split()
+    commithash = commitline[0]
+    lineno_then = int(commitline[1])
+    lineno_now = int(commitline[2])
+
+    try:
+      commit = commits[commithash]
+    except KeyError:
+      commit = Commit(commithash)
+      commits[commithash] = commit
+
+    # Read commit details until we find a context line.
+    while i < len(lines):
+      line = lines[i]
+      i += 1
+      if line.startswith('\t'):
+        break
+
+      try:
+        key, value = line.split(' ', 1)
+      except ValueError:
+        key = line
+        value = True
+      setattr(commit, key.replace('-', '_'), value)
+
+    context = line[1:]
+
+    yield BlameLine(commit, context, lineno_then, lineno_now, False)
+
+
+def print_table(outbuf, table, align):
+  """Print a 2D rectangular array, aligning columns with spaces.
+
+  Args:
+    align: string of 'l' and 'r', designating whether each column is left- or
+           right-aligned.
+  """
+  if len(table) == 0:
+    return
+
+  colwidths = None
+  for row in table:
+    if colwidths is None:
+      colwidths = [len(x) for x in row]
+    else:
+      colwidths = [max(colwidths[i], len(x)) for i, x in enumerate(row)]
+
+  for row in table:
+    cells = []
+    for i, cell in enumerate(row):
+      padding = ' ' * (colwidths[i] - len(cell))
+      if align[i] == 'r':
+        cell = padding + cell
+      elif i < len(row) - 1:
+        # Do not pad the final column if left-aligned.
+        cell += padding
+      cells.append(cell.encode('utf-8', 'replace'))
+    try:
+      outbuf.write(b' '.join(cells) + b'\n')
+    except IOError:  # pragma: no cover
+      # Can happen on Windows if the pipe is closed early.
+      pass
+
+
+def pretty_print(outbuf, parsedblame, show_filenames=False):
+  """Pretty-prints the output of parse_blame."""
+  table = []
+  for line in parsedblame:
+    author_time = git_dates.timestamp_offset_to_datetime(
+        line.commit.author_time, line.commit.author_tz)
+    row = [line.commit.commithash[:8],
+           '(' + line.commit.author,
+           git_dates.datetime_string(author_time),
+           str(line.lineno_now) + ('*' if line.modified else '') + ')',
+           line.context]
+    if show_filenames:
+      row.insert(1, line.commit.filename)
+    table.append(row)
+  print_table(outbuf, table, align='llllrl' if show_filenames else 'lllrl')
+
+
+def get_parsed_blame(filename, revision='HEAD'):
+  blame = git_common.blame(filename, revision=revision, porcelain=True)
+  return list(parse_blame(blame))
+
+
+# Map from (oldrev, newrev) to hunk list (caching the results of git diff, but
+# only the hunk line numbers, not the actual diff contents).
+# hunk list contains (old, new) pairs, where old and new are (start, length)
+# pairs. A hunk list can also be None (if the diff failed).
+diff_hunks_cache = {}
+
+
+def cache_diff_hunks(oldrev, newrev):
+  def parse_start_length(s):
+    # Chop the '-' or '+'.
+    s = s[1:]
+    # Length is optional (defaults to 1).
+    try:
+      start, length = s.split(',')
+    except ValueError:
+      start = s
+      length = 1
+    return int(start), int(length)
+
+  try:
+    return diff_hunks_cache[(oldrev, newrev)]
+  except KeyError:
+    pass
+
+  # Use -U0 to get the smallest possible hunks.
+  diff = git_common.diff(oldrev, newrev, '-U0')
+
+  # Get all the hunks.
+  hunks = []
+  for line in diff.split('\n'):
+    if not line.startswith('@@'):
+      continue
+    ranges = line.split(' ', 3)[1:3]
+    ranges = tuple(parse_start_length(r) for r in ranges)
+    hunks.append(ranges)
+
+  diff_hunks_cache[(oldrev, newrev)] = hunks
+  return hunks
+
+
+def approx_lineno_across_revs(filename, newfilename, revision, newrevision,
+                              lineno):
+  """Computes the approximate movement of a line number between two revisions.
+
+  Consider line |lineno| in |filename| at |revision|. This function computes the
+  line number of that line in |newfilename| at |newrevision|. This is
+  necessarily approximate.
+
+  Args:
+    filename: The file (within the repo) at |revision|.
+    newfilename: The name of the same file at |newrevision|.
+    revision: A git revision.
+    newrevision: Another git revision. Note: Can be ahead or behind |revision|.
+    lineno: Line number within |filename| at |revision|.
+
+  Returns:
+    Line number within |newfilename| at |newrevision|.
+  """
+  # This doesn't work that well if there are a lot of line changes within the
+  # hunk (demonstrated by GitHyperBlameLineMotionTest.testIntraHunkLineMotion).
+  # A fuzzy heuristic that takes the text of the new line and tries to find a
+  # deleted line within the hunk that mostly matches the new line could help.
+
+  # Use the <revision>:<filename> syntax to diff between two blobs. This is the
+  # only way to diff a file that has been renamed.
+  old = '%s:%s' % (revision, filename)
+  new = '%s:%s' % (newrevision, newfilename)
+  hunks = cache_diff_hunks(old, new)
+
+  cumulative_offset = 0
+
+  # Find the hunk containing lineno (if any).
+  for (oldstart, oldlength), (newstart, newlength) in hunks:
+    cumulative_offset += newlength - oldlength
+
+    if lineno >= oldstart + oldlength:
+      # Not there yet.
+      continue
+
+    if lineno < oldstart:
+      # Gone too far.
+      break
+
+    # lineno is in [oldstart, oldlength] at revision; [newstart, newlength] at
+    # newrevision.
+
+    # If newlength == 0, newstart will be the line before the deleted hunk.
+    # Since the line must have been deleted, just return that as the nearest
+    # line in the new file. Caution: newstart can be 0 in this case.
+    if newlength == 0:
+      return max(1, newstart)
+
+    newend = newstart + newlength - 1
+
+    # Move lineno based on the amount the entire hunk shifted.
+    lineno = lineno + newstart - oldstart
+    # Constrain the output within the range [newstart, newend].
+    return min(newend, max(newstart, lineno))
+
+  # Wasn't in a hunk. Figure out the line motion based on the difference in
+  # length between the hunks seen so far.
+  return lineno + cumulative_offset
+
+
+def hyper_blame(outbuf, ignored, filename, revision):
+  # Map from commit to parsed blame from that commit.
+  blame_from = {}
+  filename = os.path.normpath(filename)
+
+  def cache_blame_from(filename, commithash):
+    try:
+      return blame_from[commithash]
+    except KeyError:
+      parsed = get_parsed_blame(filename, commithash)
+      blame_from[commithash] = parsed
+      return parsed
+
+  try:
+    parsed = cache_blame_from(filename, git_common.hash_one(revision))
+  except subprocess2.CalledProcessError as e:
+    sys.stderr.write(e.stderr.decode())
+    return e.returncode
+
+  new_parsed = []
+
+  # We don't show filenames in blame output unless we have to.
+  show_filenames = False
+
+  for line in parsed:
+    # If a line references an ignored commit, blame that commit's parent
+    # repeatedly until we find a non-ignored commit.
+    while line.commit.commithash in ignored:
+      if line.commit.previous is None:
+        # You can't ignore the commit that added this file.
+        break
+
+      previouscommit, previousfilename = line.commit.previous.split(' ', 1)
+      parent_blame = cache_blame_from(previousfilename, previouscommit)
+
+      if len(parent_blame) == 0:
+        # The previous version of this file was empty, therefore, you can't
+        # ignore this commit.
+        break
+
+      # line.lineno_then is the line number in question at line.commit. We need
+      # to translate that line number so that it refers to the position of the
+      # same line on previouscommit.
+      lineno_previous = approx_lineno_across_revs(
+          line.commit.filename, previousfilename, line.commit.commithash,
+          previouscommit, line.lineno_then)
+      logging.debug('ignore commit %s on line p%d/t%d/n%d',
+                    line.commit.commithash, lineno_previous, line.lineno_then,
+                    line.lineno_now)
+
+      # Get the line at lineno_previous in the parent commit.
+      assert 1 <= lineno_previous <= len(parent_blame)
+      newline = parent_blame[lineno_previous - 1]
+
+      # Replace the commit and lineno_then, but not the lineno_now or context.
+      line = BlameLine(newline.commit, line.context, newline.lineno_then,
+                       line.lineno_now, True)
+      logging.debug('    replacing with %r', line)
+
+    # If any line has a different filename to the file's current name, turn on
+    # filename display for the entire blame output.
+    # Use normpath to make variable consistent across platforms.
+    if os.path.normpath(line.commit.filename) != filename:
+      show_filenames = True
+
+    new_parsed.append(line)
+
+  pretty_print(outbuf, new_parsed, show_filenames=show_filenames)
+
+  return 0
+
+
+def parse_ignore_file(ignore_file):
+  for line in ignore_file:
+    line = line.split('#', 1)[0].strip()
+    if line:
+      yield line
+
+
+def main(args, outbuf):
+  parser = argparse.ArgumentParser(
+      prog='git hyper-blame',
+      description='git blame with support for ignoring certain commits.')
+  parser.add_argument('-i', metavar='REVISION', action='append', dest='ignored',
+                      default=[], help='a revision to ignore')
+  parser.add_argument('--ignore-file', metavar='FILE', dest='ignore_file',
+                      help='a file containing a list of revisions to ignore')
+  parser.add_argument('--no-default-ignores', dest='no_default_ignores',
+                      action='store_true',
+                      help='Do not ignore commits from .git-blame-ignore-revs.')
+  parser.add_argument('revision', nargs='?', default='HEAD', metavar='REVISION',
+                      help='revision to look at')
+  parser.add_argument('filename', metavar='FILE', help='filename to blame')
+
+  args = parser.parse_args(args)
+  try:
+    repo_root = git_common.repo_root()
+  except subprocess2.CalledProcessError as e:
+    sys.stderr.write(e.stderr.decode())
+    return e.returncode
+
+  # Make filename relative to the repository root, and cd to the root dir (so
+  # all filenames throughout this script are relative to the root).
+  filename = os.path.relpath(args.filename, repo_root)
+  os.chdir(repo_root)
+
+  # Normalize filename so we can compare it to other filenames git gives us.
+  filename = os.path.normpath(filename)
+  filename = os.path.normcase(filename)
+
+  ignored_list = list(args.ignored)
+  if not args.no_default_ignores and os.path.exists(DEFAULT_IGNORE_FILE_NAME):
+    with open(DEFAULT_IGNORE_FILE_NAME) as ignore_file:
+      ignored_list.extend(parse_ignore_file(ignore_file))
+
+  if args.ignore_file:
+    with open(args.ignore_file) as ignore_file:
+      ignored_list.extend(parse_ignore_file(ignore_file))
+
+  ignored = set()
+  for c in ignored_list:
+    try:
+      ignored.add(git_common.hash_one(c))
+    except subprocess2.CalledProcessError as e:
+      # Custom warning string (the message from git-rev-parse is inappropriate).
+      sys.stderr.write('warning: unknown revision \'%s\'.\n' % c)
+
+  return hyper_blame(outbuf, ignored, filename, args.revision)
+
+
+if __name__ == '__main__':  # pragma: no cover
+  setup_color.init()
+  with git_common.less() as less_input:
+    sys.exit(main(sys.argv[1:], less_input))