libv8 8.4.255.0

data/vendor/depot_tools/git_rebase_update.py

@@ -0,0 +1,351 @@
+#!/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.
+
+"""
+Tool to update all branches to have the latest changes from their upstreams.
+"""
+
+from __future__ import print_function
+
+import argparse
+import collections
+import logging
+import sys
+import textwrap
+import os
+
+from fnmatch import fnmatch
+from pprint import pformat
+
+import git_common as git
+
+
+STARTING_BRANCH_KEY = 'depot-tools.rebase-update.starting-branch'
+STARTING_WORKDIR_KEY = 'depot-tools.rebase-update.starting-workdir'
+
+
+def find_return_branch_workdir():
+  """Finds the branch and working directory which we should return to after
+  rebase-update completes.
+
+  These values may persist across multiple invocations of rebase-update, if
+  rebase-update runs into a conflict mid-way.
+  """
+  return_branch = git.get_config(STARTING_BRANCH_KEY)
+  workdir = git.get_config(STARTING_WORKDIR_KEY)
+  if not return_branch:
+    workdir = os.getcwd()
+    git.set_config(STARTING_WORKDIR_KEY, workdir)
+    return_branch = git.current_branch()
+    if return_branch != 'HEAD':
+      git.set_config(STARTING_BRANCH_KEY, return_branch)
+
+  return return_branch, workdir
+
+
+def fetch_remotes(branch_tree):
+  """Fetches all remotes which are needed to update |branch_tree|."""
+  fetch_tags = False
+  remotes = set()
+  tag_set = git.tags()
+  fetchspec_map = {}
+  all_fetchspec_configs = git.get_config_regexp(r'^remote\..*\.fetch')
+  for fetchspec_config in all_fetchspec_configs:
+    key, _, fetchspec = fetchspec_config.partition(' ')
+    dest_spec = fetchspec.partition(':')[2]
+    remote_name = key.split('.')[1]
+    fetchspec_map[dest_spec] = remote_name
+  for parent in branch_tree.values():
+    if parent in tag_set:
+      fetch_tags = True
+    else:
+      full_ref = git.run('rev-parse', '--symbolic-full-name', parent)
+      for dest_spec, remote_name in fetchspec_map.items():
+        if fnmatch(full_ref, dest_spec):
+          remotes.add(remote_name)
+          break
+
+  fetch_args = []
+  if fetch_tags:
+    # Need to fetch all because we don't know what remote the tag comes from :(
+    # TODO(iannucci): assert that the tags are in the remote fetch refspec
+    fetch_args = ['--all']
+  else:
+    fetch_args.append('--multiple')
+    fetch_args.extend(remotes)
+  # TODO(iannucci): Should we fetch git-svn?
+
+  if not fetch_args:  # pragma: no cover
+    print('Nothing to fetch.')
+  else:
+    git.run_with_stderr('fetch', *fetch_args, stdout=sys.stdout,
+                        stderr=sys.stderr)
+
+
+def remove_empty_branches(branch_tree):
+  tag_set = git.tags()
+  ensure_root_checkout = git.once(lambda: git.run('checkout', git.root()))
+
+  deletions = {}
+  reparents = {}
+  downstreams = collections.defaultdict(list)
+  for branch, parent in git.topo_iter(branch_tree, top_down=False):
+    if git.is_dormant(branch):
+      continue
+
+    downstreams[parent].append(branch)
+
+    # If branch and parent have the same tree, then branch has to be marked
+    # for deletion and its children and grand-children reparented to parent.
+    if git.hash_one(branch+":") == git.hash_one(parent+":"):
+      ensure_root_checkout()
+
+      logging.debug('branch %s merged to %s', branch, parent)
+
+      # Mark branch for deletion while remembering the ordering, then add all
+      # its children as grand-children of its parent and record reparenting
+      # information if necessary.
+      deletions[branch] = len(deletions)
+
+      for down in downstreams[branch]:
+        if down in deletions:
+          continue
+
+        # Record the new and old parent for down, or update such a record
+        # if it already exists. Keep track of the ordering so that reparenting
+        # happen in topological order.
+        downstreams[parent].append(down)
+        if down not in reparents:
+          reparents[down] = (len(reparents), parent, branch)
+        else:
+          order, _, old_parent = reparents[down]
+          reparents[down] = (order, parent, old_parent)
+
+  # Apply all reparenting recorded, in order.
+  for branch, value in sorted(reparents.items(), key=lambda x:x[1][0]):
+    _, parent, old_parent = value
+    if parent in tag_set:
+      git.set_branch_config(branch, 'remote', '.')
+      git.set_branch_config(branch, 'merge', 'refs/tags/%s' % parent)
+      print('Reparented %s to track %s [tag] (was tracking %s)' %
+            (branch, parent, old_parent))
+    else:
+      git.run('branch', '--set-upstream-to', parent, branch)
+      print('Reparented %s to track %s (was tracking %s)' % (branch, parent,
+                                                             old_parent))
+
+  # Apply all deletions recorded, in order.
+  for branch, _ in sorted(deletions.items(), key=lambda x: x[1]):
+    print(git.run('branch', '-d', branch))
+
+
+def rebase_branch(branch, parent, start_hash):
+  logging.debug('considering %s(%s) -> %s(%s) : %s',
+                branch, git.hash_one(branch), parent, git.hash_one(parent),
+                start_hash)
+
+  # If parent has FROZEN commits, don't base branch on top of them. Instead,
+  # base branch on top of whatever commit is before them.
+  back_ups = 0
+  orig_parent = parent
+  while git.run('log', '-n1', '--format=%s',
+                parent, '--').startswith(git.FREEZE):
+    back_ups += 1
+    parent = git.run('rev-parse', parent+'~')
+
+  if back_ups:
+    logging.debug('Backed parent up by %d from %s to %s',
+                  back_ups, orig_parent, parent)
+
+  if git.hash_one(parent) != start_hash:
+    # Try a plain rebase first
+    print('Rebasing:', branch)
+    rebase_ret = git.rebase(parent, start_hash, branch, abort=True)
+    if not rebase_ret.success:
+      # TODO(iannucci): Find collapsible branches in a smarter way?
+      print("Failed! Attempting to squash", branch, "...", end=' ')
+      sys.stdout.flush()
+      squash_branch = branch+"_squash_attempt"
+      git.run('checkout', '-b', squash_branch)
+      git.squash_current_branch(merge_base=start_hash)
+
+      # Try to rebase the branch_squash_attempt branch to see if it's empty.
+      squash_ret = git.rebase(parent, start_hash, squash_branch, abort=True)
+      empty_rebase = git.hash_one(squash_branch) == git.hash_one(parent)
+      git.run('checkout', branch)
+      git.run('branch', '-D', squash_branch)
+      if squash_ret.success and empty_rebase:
+        print('Success!')
+        git.squash_current_branch(merge_base=start_hash)
+        git.rebase(parent, start_hash, branch)
+      else:
+        print("Failed!")
+        print()
+
+        # rebase and leave in mid-rebase state.
+        # This second rebase attempt should always fail in the same
+        # way that the first one does.  If it magically succeeds then
+        # something very strange has happened.
+        second_rebase_ret = git.rebase(parent, start_hash, branch)
+        if second_rebase_ret.success: # pragma: no cover
+          print("Second rebase succeeded unexpectedly!")
+          print("Please see: http://crbug.com/425696")
+          print("First rebased failed with:")
+          print(rebase_ret.stderr)
+        else:
+          print("Here's what git-rebase (squashed) had to say:")
+          print()
+          print(squash_ret.stdout)
+          print(squash_ret.stderr)
+          print(textwrap.dedent("""\
+          Squashing failed. You probably have a real merge conflict.
+
+          Your working copy is in mid-rebase. Either:
+           * completely resolve like a normal git-rebase; OR
+           * abort the rebase and mark this branch as dormant:
+                 git config branch.%s.dormant true
+
+          And then run `git rebase-update` again to resume.
+          """ % branch))
+          return False
+  else:
+    print('%s up-to-date' % branch)
+
+  git.remove_merge_base(branch)
+  git.get_or_create_merge_base(branch)
+
+  return True
+
+
+def main(args=None):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--verbose', '-v', action='store_true')
+  parser.add_argument('--keep-going', '-k', action='store_true',
+                      help='Keep processing past failed rebases.')
+  parser.add_argument('--no_fetch', '--no-fetch', '-n',
+                      action='store_true',
+                      help='Skip fetching remotes.')
+  parser.add_argument(
+      '--current', action='store_true', help='Only rebase the current branch.')
+  parser.add_argument('branches', nargs='*',
+                      help='Branches to be rebased. All branches are assumed '
+                           'if none specified.')
+  parser.add_argument('--keep-empty', '-e', action='store_true',
+                      help='Do not automatically delete empty branches.')
+  opts = parser.parse_args(args)
+
+  if opts.verbose:  # pragma: no cover
+    logging.getLogger().setLevel(logging.DEBUG)
+
+  # TODO(iannucci): snapshot all branches somehow, so we can implement
+  #                 `git rebase-update --undo`.
+  #   * Perhaps just copy packed-refs + refs/ + logs/ to the side?
+  #     * commit them to a secret ref?
+  #       * Then we could view a summary of each run as a
+  #         `diff --stat` on that secret ref.
+
+  if git.in_rebase():
+    # TODO(iannucci): Be able to resume rebase with flags like --continue,
+    # etc.
+    print('Rebase in progress. Please complete the rebase before running '
+          '`git rebase-update`.')
+    return 1
+
+  return_branch, return_workdir = find_return_branch_workdir()
+  os.chdir(git.run('rev-parse', '--show-toplevel'))
+
+  if git.current_branch() == 'HEAD':
+    if git.run('status', '--porcelain'):
+      print('Cannot rebase-update with detached head + uncommitted changes.')
+      return 1
+  else:
+    git.freeze()  # just in case there are any local changes.
+
+  branches_to_rebase = set(opts.branches)
+  if opts.current:
+    branches_to_rebase.add(git.current_branch())
+
+  skipped, branch_tree = git.get_branch_tree()
+  if branches_to_rebase:
+    skipped = set(skipped).intersection(branches_to_rebase)
+  for branch in skipped:
+    print('Skipping %s: No upstream specified' % branch)
+
+  if not opts.no_fetch:
+    fetch_remotes(branch_tree)
+
+  merge_base = {}
+  for branch, parent in branch_tree.items():
+    merge_base[branch] = git.get_or_create_merge_base(branch, parent)
+
+  logging.debug('branch_tree: %s' % pformat(branch_tree))
+  logging.debug('merge_base: %s' % pformat(merge_base))
+
+  retcode = 0
+  unrebased_branches = []
+  # Rebase each branch starting with the root-most branches and working
+  # towards the leaves.
+  for branch, parent in git.topo_iter(branch_tree):
+    # Only rebase specified branches, unless none specified.
+    if branches_to_rebase and branch not in branches_to_rebase:
+      continue
+    if git.is_dormant(branch):
+      print('Skipping dormant branch', branch)
+    else:
+      ret = rebase_branch(branch, parent, merge_base[branch])
+      if not ret:
+        retcode = 1
+
+        if opts.keep_going:
+          print('--keep-going set, continuing with next branch.')
+          unrebased_branches.append(branch)
+          if git.in_rebase():
+            git.run_with_retcode('rebase', '--abort')
+          if git.in_rebase():  # pragma: no cover
+            print('Failed to abort rebase. Something is really wrong.')
+            break
+        else:
+          break
+
+  if unrebased_branches:
+    print()
+    print('The following branches could not be cleanly rebased:')
+    for branch in unrebased_branches:
+      print('  %s' % branch)
+
+  if not retcode:
+    if not opts.keep_empty:
+      remove_empty_branches(branch_tree)
+
+    # return_branch may not be there any more.
+    if return_branch in git.branches():
+      git.run('checkout', return_branch)
+      git.thaw()
+    else:
+      root_branch = git.root()
+      if return_branch != 'HEAD':
+        print("%s was merged with its parent, checking out %s instead." %
+              (git.unicode_repr(return_branch), git.unicode_repr(root_branch)))
+      git.run('checkout', root_branch)
+
+    # return_workdir may also not be there any more.
+    if return_workdir:
+      try:
+        os.chdir(return_workdir)
+      except OSError as e:
+        print(
+            "Unable to return to original workdir %r: %s" % (return_workdir, e))
+    git.set_config(STARTING_BRANCH_KEY, '')
+    git.set_config(STARTING_WORKDIR_KEY, '')
+
+  return retcode
+
+
+if __name__ == '__main__':  # pragma: no cover
+  try:
+    sys.exit(main())
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_rename_branch.py

@@ -0,0 +1,55 @@
+#!/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.
+
+"""Rename the current branch while maintaining correct dependencies."""
+
+import argparse
+import sys
+
+import subprocess2
+
+from git_common import current_branch, run, set_branch_config, branch_config
+from git_common import branch_config_map
+
+def main(args):
+  current = current_branch()
+  if current == 'HEAD':
+    current = None
+  old_name_help = 'The old branch to rename.'
+  if current:
+    old_name_help += ' (default %(default)r)'
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument('old_name', nargs=('?' if current else 1),
+                      help=old_name_help, default=current)
+  parser.add_argument('new_name', help='The new branch name.')
+
+  opts = parser.parse_args(args)
+
+  # when nargs=1, we get a list :(
+  if isinstance(opts.old_name, list):
+    opts.old_name = opts.old_name[0]
+
+  try:
+    run('branch', '-m', opts.old_name, opts.new_name)
+
+    # update the downstreams
+    for branch, merge in branch_config_map('merge').items():
+      if merge == 'refs/heads/' + opts.old_name:
+        # Only care about local branches
+        if branch_config(branch, 'remote') == '.':
+          set_branch_config(branch, 'merge', 'refs/heads/' + opts.new_name)
+  except subprocess2.CalledProcessError as cpe:
+    sys.stderr.write(cpe.stderr.decode('utf-8', 'replace'))
+    return 1
+  return 0
+
+
+if __name__ == '__main__':  # pragma: no cover
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_reparent_branch.py

@@ -0,0 +1,101 @@
+#!/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.
+
+"""Change the upstream of the current branch."""
+
+from __future__ import print_function
+
+import argparse
+import sys
+
+import subprocess2
+
+from git_common import upstream, current_branch, run, tags, set_branch_config
+from git_common import get_or_create_merge_base, root, manual_merge_base
+from git_common import get_branch_tree, topo_iter
+
+import git_rebase_update
+
+def main(args):
+  root_ref = root()
+
+  parser = argparse.ArgumentParser()
+  g = parser.add_mutually_exclusive_group()
+  g.add_argument('new_parent', nargs='?',
+                 help='New parent branch (or tag) to reparent to.')
+  g.add_argument('--root', action='store_true',
+                 help='Reparent to the configured root branch (%s).' % root_ref)
+  g.add_argument('--lkgr', action='store_true',
+                 help='Reparent to the lkgr tag.')
+  opts = parser.parse_args(args)
+
+  # TODO(iannucci): Allow specification of the branch-to-reparent
+
+  branch = current_branch()
+
+  if opts.root:
+    new_parent = root_ref
+  elif opts.lkgr:
+    new_parent = 'lkgr'
+  else:
+    if not opts.new_parent:
+      parser.error('Must specify new parent somehow')
+    new_parent = opts.new_parent
+  cur_parent = upstream(branch)
+
+  if branch == 'HEAD' or not branch:
+    parser.error('Must be on the branch you want to reparent')
+  if new_parent == cur_parent:
+    parser.error('Cannot reparent a branch to its existing parent')
+
+  if not cur_parent:
+    msg = (
+      "Unable to determine %s@{upstream}.\n\nThis can happen if you didn't use "
+      "`git new-branch` to create the branch and haven't used "
+      "`git branch --set-upstream-to` to assign it one.\n\nPlease assign an "
+      "upstream branch and then run this command again."
+    )
+    print(msg % branch, file=sys.stderr)
+    return 1
+
+  mbase = get_or_create_merge_base(branch, cur_parent)
+
+  all_tags = tags()
+  if cur_parent in all_tags:
+    cur_parent += ' [tag]'
+
+  try:
+    run('show-ref', new_parent)
+  except subprocess2.CalledProcessError:
+    print('fatal: invalid reference: %s' % new_parent, file=sys.stderr)
+    return 1
+
+  if new_parent in all_tags:
+    print("Reparenting %s to track %s [tag] (was %s)" % (branch, new_parent,
+                                                         cur_parent))
+    set_branch_config(branch, 'remote', '.')
+    set_branch_config(branch, 'merge', new_parent)
+  else:
+    print("Reparenting %s to track %s (was %s)" % (branch, new_parent,
+                                                   cur_parent))
+    run('branch', '--set-upstream-to', new_parent, branch)
+
+  manual_merge_base(branch, mbase, new_parent)
+
+  # ONLY rebase-update the branch which moved (and dependants)
+  _, branch_tree = get_branch_tree()
+  branches = [branch]
+  for branch, parent in topo_iter(branch_tree):
+    if parent in branches:
+      branches.append(branch)
+  return git_rebase_update.main(['--no-fetch'] + branches)
+
+
+if __name__ == '__main__':  # pragma: no cover
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)