libv8 4.5.95.5 → 5.0.71.48.0beta2

data/vendor/depot_tools/git_common.py

@@ -22,6 +22,8 @@ import functools
 import logging
 import os
 import re
+import setup_color
+import shutil
 import signal
 import sys
 import tempfile
@@ -32,7 +34,8 @@ import subprocess2
 
 ROOT = os.path.abspath(os.path.dirname(__file__))
 
-GIT_EXE = ROOT+'\\git.bat' if sys.platform.startswith('win') else 'git'
+IS_WIN = sys.platform == 'win32'
+GIT_EXE = ROOT+'\\git.bat' if IS_WIN else 'git'
 TEST_MODE = False
 
 FREEZE = 'FREEZE'
@@ -279,15 +282,34 @@ def once(function):
 ## Git functions
 
 
+def blame(filename, revision=None, porcelain=False, *_args):
+  command = ['blame']
+  if porcelain:
+    command.append('-p')
+  if revision is not None:
+    command.append(revision)
+  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)
+  return run('config', '--get-regexp', pattern).splitlines()
+
+
 def branch_config_map(option):
   """Return {branch: <|option| value>} for all branches."""
   try:
     reg = re.compile(r'^branch\.(.*)\.%s$' % option)
-    lines = run('config', '--get-regexp', reg.pattern).splitlines()
+    lines = config_regexp(reg.pattern)
     return {reg.match(k).group(1): v for k, v in (l.split() for l in lines)}
   except subprocess2.CalledProcessError:
     return {}
@@ -353,18 +375,22 @@ def del_config(option, scope='local'):
     pass
 
 
+def diff(oldrev, newrev, *args):
+  return run('diff', oldrev, newrev, *args)
+
+
 def freeze():
   took_action = False
 
   try:
-    run('commit', '-m', FREEZE + '.indexed')
+    run('commit', '--no-verify', '-m', FREEZE + '.indexed')
     took_action = True
   except subprocess2.CalledProcessError:
     pass
 
   try:
     run('add', '-A')
-    run('commit', '-m', FREEZE + '.unindexed')
+    run('commit', '--no-verify', '-m', FREEZE + '.unindexed')
     took_action = True
   except subprocess2.CalledProcessError:
     pass
@@ -411,7 +437,7 @@ def get_or_create_merge_base(branch, parent=None):
   def is_ancestor(a, b):
     return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
 
-  if base:
+  if base and base != actual_merge_base:
     if not is_ancestor(base, branch):
       logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
       base = None
@@ -535,10 +561,39 @@ def remove_merge_base(branch):
   del_branch_config(branch, 'base-upstream')
 
 
+def repo_root():
+  """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.
+  """
+  if not setup_color.IS_TTY:
+    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]
@@ -552,7 +607,6 @@ def run_with_retcode(*cmd, **kwargs):
   except subprocess2.CalledProcessError as cpe:
     return cpe.returncode
 
-
 def run_stream(*cmd, **kwargs):
   """Runs a git command. Returns stdout as a PIPE (file-like object).
 
@@ -561,6 +615,7 @@ def run_stream(*cmd, **kwargs):
   """
   kwargs.setdefault('stderr', subprocess2.VOID)
   kwargs.setdefault('stdout', subprocess2.PIPE)
+  kwargs.setdefault('shell', False)
   cmd = (GIT_EXE, '-c', 'color.ui=never') + cmd
   proc = subprocess2.Popen(cmd, **kwargs)
   return proc.stdout
@@ -577,6 +632,7 @@ def run_stream_with_retcode(*cmd, **kwargs):
   """
   kwargs.setdefault('stderr', subprocess2.VOID)
   kwargs.setdefault('stdout', subprocess2.PIPE)
+  kwargs.setdefault('shell', False)
   cmd = (GIT_EXE, '-c', 'color.ui=never') + cmd
   try:
     proc = subprocess2.Popen(cmd, **kwargs)
@@ -600,6 +656,7 @@ def run_with_stderr(*cmd, **kwargs):
   kwargs.setdefault('stdin', subprocess2.PIPE)
   kwargs.setdefault('stdout', subprocess2.PIPE)
   kwargs.setdefault('stderr', subprocess2.PIPE)
+  kwargs.setdefault('shell', False)
   autostrip = kwargs.pop('autostrip', True)
   indata = kwargs.pop('indata', None)
 
@@ -817,3 +874,40 @@ def get_branches_info(include_tracking_status):
       missing_upstreams[info.upstream] = None
 
   return dict(info_map.items() + missing_upstreams.items())
+
+
+def make_workdir_common(repository, new_workdir, files_to_symlink,
+                        files_to_copy, symlink=None):
+  if not symlink:
+    symlink = os.symlink
+  os.makedirs(new_workdir)
+  for entry in files_to_symlink:
+    clone_file(repository, new_workdir, entry, symlink)
+  for entry in files_to_copy:
+    clone_file(repository, new_workdir, entry, shutil.copy)
+
+
+def make_workdir(repository, new_workdir):
+  GIT_DIRECTORY_WHITELIST = [
+    'config',
+    'info',
+    'hooks',
+    'logs/refs',
+    'objects',
+    'packed-refs',
+    'refs',
+    'remotes',
+    'rr-cache',
+    'svn'
+  ]
+  make_workdir_common(repository, new_workdir, GIT_DIRECTORY_WHITELIST,
+                      ['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))

data/vendor/depot_tools/git_dates.py

@@ -0,0 +1,62 @@
+# 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.
+
+"""Utility module for dealing with Git timestamps."""
+
+import datetime
+
+
+def timestamp_offset_to_datetime(timestamp, offset):
+  """Converts a timestamp + offset into a datetime.datetime.
+
+  Useful for dealing with the output of porcelain commands, which provide times
+  as timestamp and offset strings.
+
+  Args:
+    timestamp: An int UTC timestamp, or a string containing decimal digits.
+    offset: A str timezone offset. e.g., '-0800'.
+
+  Returns:
+    A tz-aware datetime.datetime for this timestamp.
+  """
+  timestamp = int(timestamp)
+  tz = FixedOffsetTZ.from_offset_string(offset)
+  return datetime.datetime.fromtimestamp(timestamp, tz)
+
+
+def datetime_string(dt):
+  """Converts a tz-aware datetime.datetime into a string in git format."""
+  return dt.strftime('%Y-%m-%d %H:%M:%S %z')
+
+
+# Adapted from: https://docs.python.org/2/library/datetime.html#tzinfo-objects
+class FixedOffsetTZ(datetime.tzinfo):
+  def __init__(self, offset, name):
+    datetime.tzinfo.__init__(self)
+    self.__offset = offset
+    self.__name = name
+
+  def __repr__(self):  # pragma: no cover
+    return '{}({!r}, {!r})'.format(type(self).__name__, self.__offset,
+                                   self.__name)
+
+  @classmethod
+  def from_offset_string(cls, offset):
+    try:
+      hours = int(offset[:-2])
+      minutes = int(offset[-2:])
+    except ValueError:
+      return cls(datetime.timedelta(0), 'UTC')
+
+    delta = datetime.timedelta(hours=hours, minutes=minutes)
+    return cls(delta, offset)
+
+  def utcoffset(self, dt):
+    return self.__offset
+
+  def tzname(self, dt):
+    return self.__name
+
+  def dst(self, dt):
+    return datetime.timedelta(0)

data/vendor/depot_tools/git_drover.py

@@ -0,0 +1,424 @@
+#!/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.
+"""git drover: A tool for merging changes to release branches."""
+
+import argparse
+import cPickle
+import functools
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import git_common
+
+
+class Error(Exception):
+  pass
+
+
+_PATCH_ERROR_MESSAGE = """Patch failed to apply.
+
+A workdir for this cherry-pick has been created in
+  {0}
+
+To continue, resolve the conflicts there and run
+  git drover --continue {0}
+
+To abort this cherry-pick run
+  git drover --abort {0}
+"""
+
+
+class PatchError(Error):
+  """An error indicating that the patch failed to apply."""
+
+  def __init__(self, workdir):
+    super(PatchError, self).__init__(_PATCH_ERROR_MESSAGE.format(workdir))
+
+
+_DEV_NULL_FILE = open(os.devnull, 'w')
+
+if os.name == 'nt':
+  # This is a just-good-enough emulation of os.symlink for drover to work on
+  # Windows. It uses junctioning of directories (most of the contents of
+  # the .git directory), but copies files. Note that we can't use
+  # CreateSymbolicLink or CreateHardLink here, as they both require elevation.
+  # Creating reparse points is what we want for the directories, but doing so
+  # is a relatively messy set of DeviceIoControl work at the API level, so we
+  # simply shell to `mklink /j` instead.
+  def emulate_symlink_windows(source, link_name):
+    if os.path.isdir(source):
+      subprocess.check_call(['mklink', '/j',
+                             link_name.replace('/', '\\'),
+                             source.replace('/', '\\')],
+                            shell=True)
+    else:
+      shutil.copy(source, link_name)
+  mk_symlink = emulate_symlink_windows
+else:
+  mk_symlink = os.symlink
+
+
+class _Drover(object):
+
+  def __init__(self, branch, revision, parent_repo, dry_run, verbose):
+    self._branch = branch
+    self._branch_ref = 'refs/remotes/branch-heads/%s' % branch
+    self._revision = revision
+    self._parent_repo = os.path.abspath(parent_repo)
+    self._dry_run = dry_run
+    self._workdir = None
+    self._branch_name = None
+    self._needs_cleanup = True
+    self._verbose = verbose
+    self._process_options()
+
+  def _process_options(self):
+    if self._verbose:
+      logging.getLogger().setLevel(logging.DEBUG)
+
+
+  @classmethod
+  def resume(cls, workdir):
+    """Continues a cherry-pick that required manual resolution.
+
+    Args:
+      workdir: A string containing the path to the workdir used by drover.
+    """
+    drover = cls._restore_drover(workdir)
+    drover._continue()
+
+  @classmethod
+  def abort(cls, workdir):
+    """Aborts a cherry-pick that required manual resolution.
+
+    Args:
+      workdir: A string containing the path to the workdir used by drover.
+    """
+    drover = cls._restore_drover(workdir)
+    drover._cleanup()
+
+  @staticmethod
+  def _restore_drover(workdir):
+    """Restores a saved drover state contained within a workdir.
+
+    Args:
+      workdir: A string containing the path to the workdir used by drover.
+    """
+    try:
+      with open(os.path.join(workdir, '.git', 'drover'), 'rb') as f:
+        drover = cPickle.load(f)
+        drover._process_options()
+        return drover
+    except (IOError, cPickle.UnpicklingError):
+      raise Error('%r is not git drover workdir' % workdir)
+
+  def _continue(self):
+    if os.path.exists(os.path.join(self._workdir, '.git', 'CHERRY_PICK_HEAD')):
+      self._run_git_command(
+          ['commit', '--no-edit'],
+          error_message='All conflicts must be resolved before continuing')
+
+    if self._upload_and_land():
+      # Only clean up the workdir on success. The manually resolved cherry-pick
+      # can be reused if the user cancels before landing.
+      self._cleanup()
+
+  def run(self):
+    """Runs this Drover instance.
+
+    Raises:
+      Error: An error occurred while attempting to cherry-pick this change.
+    """
+    try:
+      self._run_internal()
+    finally:
+      self._cleanup()
+
+  def _run_internal(self):
+    self._check_inputs()
+    if not self._confirm('Going to cherry-pick\n"""\n%s"""\nto %s.' % (
+        self._run_git_command(['show', '-s', self._revision]), self._branch)):
+      return
+    self._create_checkout()
+    self._perform_cherry_pick()
+    self._upload_and_land()
+
+  def _cleanup(self):
+    if not self._needs_cleanup:
+      return
+
+    if self._workdir:
+      logging.debug('Deleting %s', self._workdir)
+      if os.name == 'nt':
+        try:
+          # Use rmdir to properly handle the junctions we created.
+          subprocess.check_call(
+              ['rmdir', '/s', '/q', self._workdir], shell=True)
+        except subprocess.CalledProcessError:
+          logging.error(
+              'Failed to delete workdir %r. Please remove it manually.',
+              self._workdir)
+      else:
+        shutil.rmtree(self._workdir)
+    self._workdir = None
+    if self._branch_name:
+      self._run_git_command(['branch', '-D', self._branch_name])
+
+  @staticmethod
+  def _confirm(message):
+    """Show a confirmation prompt with the given message.
+
+    Returns:
+      A bool representing whether the user wishes to continue.
+    """
+    result = ''
+    while result not in ('y', 'n'):
+      try:
+        result = raw_input('%s Continue (y/n)? ' % message)
+      except EOFError:
+        result = 'n'
+    return result == 'y'
+
+  def _check_inputs(self):
+    """Check the input arguments and ensure the parent repo is up to date."""
+
+    if not os.path.isdir(self._parent_repo):
+      raise Error('Invalid parent repo path %r' % self._parent_repo)
+
+    self._run_git_command(['--help'], error_message='Unable to run git')
+    self._run_git_command(['status'],
+                          error_message='%r is not a valid git repo' %
+                          os.path.abspath(self._parent_repo))
+    self._run_git_command(['fetch', 'origin'],
+                          error_message='Failed to fetch origin')
+    self._run_git_command(
+        ['rev-parse', '%s^{commit}' % self._branch_ref],
+        error_message='Branch %s not found' % self._branch_ref)
+    self._run_git_command(
+        ['rev-parse', '%s^{commit}' % self._revision],
+        error_message='Revision "%s" not found' % self._revision)
+
+  FILES_TO_LINK = [
+      'refs',
+      'logs/refs',
+      'info/refs',
+      'info/exclude',
+      'objects',
+      'hooks',
+      'packed-refs',
+      'remotes',
+      'rr-cache',
+      'svn',
+  ]
+  FILES_TO_COPY = ['config', 'HEAD']
+
+  def _create_checkout(self):
+    """Creates a checkout to use for cherry-picking.
+
+    This creates a checkout similarly to git-new-workdir. Most of the .git
+    directory is shared with the |self._parent_repo| using symlinks. This
+    differs from git-new-workdir in that the config is forked instead of shared.
+    This is so the new workdir can be a sparse checkout without affecting
+    |self._parent_repo|.
+    """
+    parent_git_dir = os.path.join(self._parent_repo, self._run_git_command(
+        ['rev-parse', '--git-dir']).strip())
+    self._workdir = tempfile.mkdtemp(prefix='drover_%s_' % self._branch)
+    logging.debug('Creating checkout in %s', self._workdir)
+    git_dir = os.path.join(self._workdir, '.git')
+    git_common.make_workdir_common(parent_git_dir, git_dir, self.FILES_TO_LINK,
+                                   self.FILES_TO_COPY, mk_symlink)
+    self._run_git_command(['config', 'core.sparsecheckout', 'true'])
+    with open(os.path.join(git_dir, 'info', 'sparse-checkout'), 'w') as f:
+      f.write('/codereview.settings')
+
+    branch_name = os.path.split(self._workdir)[-1]
+    self._run_git_command(['checkout', '-b', branch_name, self._branch_ref])
+    self._branch_name = branch_name
+
+  def _perform_cherry_pick(self):
+    try:
+      self._run_git_command(['cherry-pick', '-x', self._revision],
+                            error_message='Patch failed to apply')
+    except Error:
+      self._prepare_manual_resolve()
+      self._save_state()
+      self._needs_cleanup = False
+      raise PatchError(self._workdir)
+
+  def _save_state(self):
+    """Saves the state of this Drover instances to the workdir."""
+    with open(os.path.join(self._workdir, '.git', 'drover'), 'wb') as f:
+      cPickle.dump(self, f)
+
+  def _prepare_manual_resolve(self):
+    """Prepare the workdir for the user to manually resolve the cherry-pick."""
+    # Files that have been deleted between branch and cherry-pick will not have
+    # their skip-worktree bit set so set it manually for those files to avoid
+    # git status incorrectly listing them as unstaged deletes.
+    repo_status = self._run_git_command(['status', '--porcelain']).splitlines()
+    extra_files = [f[3:] for f in repo_status if f[:2] == ' D']
+    if extra_files:
+      self._run_git_command(['update-index', '--skip-worktree', '--'] +
+                            extra_files)
+
+  def _upload_and_land(self):
+    if self._dry_run:
+      logging.info('--dry_run enabled; not landing.')
+      return True
+
+    self._run_git_command(['reset', '--hard'])
+    self._run_git_command(['cl', 'upload'],
+                          error_message='Upload failed',
+                          interactive=True)
+
+    if not self._confirm('About to land on %s.' % self._branch):
+      return False
+    self._run_git_command(['cl', 'land', '--bypass-hooks'], interactive=True)
+    return True
+
+  def _run_git_command(self, args, error_message=None, interactive=False):
+    """Runs a git command.
+
+    Args:
+      args: A list of strings containing the args to pass to git.
+      error_message: A string containing the error message to report if the
+          command fails.
+      interactive: A bool containing whether the command requires user
+          interaction. If false, the command will be provided with no input and
+          the output is captured.
+
+    Raises:
+      Error: The command failed to complete successfully.
+    """
+    cwd = self._workdir if self._workdir else self._parent_repo
+    logging.debug('Running git %s (cwd %r)', ' '.join('%s' % arg
+                                                      for arg in args), cwd)
+
+    run = subprocess.check_call if interactive else subprocess.check_output
+
+    # Discard stderr unless verbose is enabled.
+    stderr = None if self._verbose else _DEV_NULL_FILE
+
+    try:
+      return run(['git'] + args, shell=False, cwd=cwd, stderr=stderr)
+    except (OSError, subprocess.CalledProcessError) as e:
+      if error_message:
+        raise Error(error_message)
+      else:
+        raise Error('Command %r failed: %s' % (' '.join(args), e))
+
+
+def cherry_pick_change(branch, revision, parent_repo, dry_run, verbose=False):
+  """Cherry-picks a change into a branch.
+
+  Args:
+    branch: A string containing the release branch number to which to
+        cherry-pick.
+    revision: A string containing the revision to cherry-pick. It can be any
+        string that git-rev-parse can identify as referring to a single
+        revision.
+    parent_repo: A string containing the path to the parent repo to use for this
+        cherry-pick.
+    dry_run: A bool containing whether to stop before uploading the
+        cherry-pick cl.
+    verbose: A bool containing whether to print verbose logging.
+
+  Raises:
+    Error: An error occurred while attempting to cherry-pick |cl| to |branch|.
+  """
+  drover = _Drover(branch, revision, parent_repo, dry_run, verbose)
+  drover.run()
+
+
+def continue_cherry_pick(workdir):
+  """Continues a cherry-pick that required manual resolution.
+
+  Args:
+    workdir: A string containing the path to the workdir used by drover.
+  """
+  _Drover.resume(workdir)
+
+
+def abort_cherry_pick(workdir):
+  """Aborts a cherry-pick that required manual resolution.
+
+  Args:
+    workdir: A string containing the path to the workdir used by drover.
+  """
+  _Drover.abort(workdir)
+
+
+def main():
+  parser = argparse.ArgumentParser(
+      description='Cherry-pick a change into a release branch.')
+  group = parser.add_mutually_exclusive_group(required=True)
+  parser.add_argument(
+      '--branch',
+      type=str,
+      metavar='<branch>',
+      help='the name of the branch to which to cherry-pick; e.g. 1234')
+  group.add_argument(
+      '--cherry-pick',
+      type=str,
+      metavar='<change>',
+      help=('the change to cherry-pick; this can be any string '
+            'that unambiguously refers to a revision not involving HEAD'))
+  group.add_argument(
+      '--continue',
+      type=str,
+      nargs='?',
+      dest='resume',
+      const=os.path.abspath('.'),
+      metavar='path_to_workdir',
+      help='Continue a drover cherry-pick after resolving conflicts')
+  group.add_argument('--abort',
+                     type=str,
+                     nargs='?',
+                     const=os.path.abspath('.'),
+                     metavar='path_to_workdir',
+                     help='Abort a drover cherry-pick')
+  parser.add_argument(
+      '--parent_checkout',
+      type=str,
+      default=os.path.abspath('.'),
+      metavar='<path_to_parent_checkout>',
+      help=('the path to the chromium checkout to use as the source for a '
+            'creating git-new-workdir workdir to use for cherry-picking; '
+            'if unspecified, the current directory is used'))
+  parser.add_argument(
+      '--dry-run',
+      action='store_true',
+      default=False,
+      help=("don't actually upload and land; "
+            "just check that cherry-picking would succeed"))
+  parser.add_argument('-v',
+                      '--verbose',
+                      action='store_true',
+                      default=False,
+                      help='show verbose logging')
+  options = parser.parse_args()
+  try:
+    if options.resume:
+      _Drover.resume(options.resume)
+    elif options.abort:
+      _Drover.abort(options.abort)
+    else:
+      if not options.branch:
+        parser.error('argument --branch is required for --cherry-pick')
+      cherry_pick_change(options.branch, options.cherry_pick,
+                         options.parent_checkout, options.dry_run,
+                         options.verbose)
+  except Error as e:
+    print 'Error:', e.message
+    sys.exit(128)
+
+
+if __name__ == '__main__':
+  main()