ABANDONED. Remove obsolete git cl dcommit.

git_cl.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld and Gerrit."""
 
 from __future__ import print_function
@@ skipping 3740 matching lines @@
 
 
 def IsSubmoduleMergeCommit(ref):
   # When submodules are added to the repo, we expect there to be a single
   # non-git-svn merge commit at remote HEAD with a signature comment.
   pattern = '^SVN changes up to revision [0-9]*$'
   cmd = ['rev-list', '--merges', '--grep=%s' % pattern, '%s^!' % ref]
   return RunGit(cmd) != ''
 
 
-def SendUpstream(parser, args, cmd):
-  """Common code for CMDland and CmdDCommit
+def SendUpstream(parser, args):
+  """Common code for CMDland
 
   In case of Gerrit, uses Gerrit REST api to "submit" the issue, which pushes
   upstream and closes the issue automatically and atomically.
 
   Otherwise (in case of Rietveld):
     Squashes branch into a single commit.
     Updates changelog with metadata (e.g. pointer to review).
-    Pushes/dcommits the code upstream.
+    Pushes the code upstream.
     Updates review and closes.
   """
   parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
                     help='bypass upload presubmit hook')
   parser.add_option('-m', dest='message',
                     help="override review description")
   parser.add_option('-f', action='store_true', dest='force',
                     help="force yes to questions (don't prompt)")
   parser.add_option('-c', dest='contributor',
                     help="external contributor for patch (appended to " +
@@ skipping 32 matching lines @@
     print()
     print('Either reparent this branch on top of origin/master:')
     print('  git reparent-branch --root')
     print()
     print('OR run `git rebase-update` if you think the parent branch is ')
     print('already committed.')
     print()
     print('  Current parent: %r' % upstream_branch)
     return 1
 
-  if not args or cmd == 'land':
+  if not args:
     # Default to merging against our best guess of the upstream branch.
     args = [cl.GetUpstreamBranch()]
 
   if options.contributor:
     if not re.match('^.*\s<\S+@\S+>$', options.contributor):
       print("Please provide contibutor as 'First Last <email@example.com>'")
       return 1
 
   base_branch = args[0]
   base_has_submodules = IsSubmoduleMergeCommit(base_branch)
 
-  if git_common.is_dirty_git_tree(cmd):
+  if git_common.is_dirty_git_tree(cmd='land'):
     return 1
 
   # This rev-list syntax means "show all commits not in my branch that
   # are in base_branch".
   upstream_commits = RunGit(['rev-list', '^' + cl.GetBranchRef(),
                              base_branch]).splitlines()
   if upstream_commits:
     print('Base branch "%s" has %d commits '
           'not in this branch.' % (base_branch, len(upstream_commits)))
-    print('Run "git merge %s" before attempting to %s.' % (base_branch, cmd))
+    print('Run "git merge %s" before attempting to land.' % (base_branch,))
     return 1
 
   # This is the revision `svn dcommit` will commit on top of.
   svn_head = None
-  if cmd == 'dcommit' or base_has_submodules:
+  if base_has_submodules:
     svn_head = RunGit(['log', '--grep=^git-svn-id:', '-1',
                        '--pretty=format:%H'])
 
-  if cmd == 'dcommit':
-    # If the base_head is a submodule merge commit, the first parent of the
-    # base_head should be a git-svn commit, which is what we're interested in.
-    base_svn_head = base_branch
-    if base_has_submodules:
-      base_svn_head += '^1'
-
-    extra_commits = RunGit(['rev-list', '^' + svn_head, base_svn_head])
-    if extra_commits:
-      print('This branch has %d additional commits not upstreamed yet.'
-            % len(extra_commits.splitlines()))
-      print('Upstream "%s" or rebase this branch on top of the upstream trunk '
-            'before attempting to %s.' % (base_branch, cmd))
-      return 1
-
   merge_base = RunGit(['merge-base', base_branch, 'HEAD']).strip()
   if not options.bypass_hooks:
     author = None
     if options.contributor:
       author = re.search(r'\<(.*)\>', options.contributor).group(1)
     hook_results = cl.RunHook(
         committing=True,
         may_prompt=not options.force,
         verbose=options.verbose,
         change=cl.GetChange(merge_base, author))
     if not hook_results.should_continue():
       return 1
 
     # Check the tree status if the tree status URL is set.
     status = GetTreeStatus()
     if 'closed' == status:
       print('The tree is closed.  Please wait for it to reopen. Use '
-            '"git cl %s --bypass-hooks" to commit on a closed tree.' % cmd)
+            '"git cl land --bypass-hooks" to commit on a closed tree.')
       return 1
     elif 'unknown' == status:
       print('Unable to determine tree status.  Please verify manually and '
-            'use "git cl %s --bypass-hooks" to commit on a closed tree.' % cmd)
+            'use "git cl land --bypass-hooks" to commit on a closed tree.')
       return 1
 
   change_desc = ChangeDescription(options.message)
   if not change_desc.description and cl.GetIssue():
     change_desc = ChangeDescription(cl.GetDescription())
 
   if not change_desc.description:
     if not cl.GetIssue() and options.bypass_hooks:
       change_desc = ChangeDescription(CreateDescriptionFromLog([merge_base]))
     else:
@@ skipping 62 matching lines @@
             'commit', '--author', options.contributor,
             '-m', commit_desc.description,
           ])
     else:
       RunGit(['commit', '-m', commit_desc.description])
     if base_has_submodules:
       cherry_pick_commit = RunGit(['rev-list', 'HEAD^!']).rstrip()
       RunGit(['branch', CHERRY_PICK_BRANCH, svn_head])
       RunGit(['checkout', CHERRY_PICK_BRANCH])
       RunGit(['cherry-pick', cherry_pick_commit])
-    if cmd == 'land':
-      remote, branch = cl.FetchUpstreamTuple(cl.GetBranch())
-      mirror = settings.GetGitMirror(remote)
-      pushurl = mirror.url if mirror else remote
-      pending_prefix = settings.GetPendingRefPrefix()
-      if not pending_prefix or branch.startswith(pending_prefix):
-        # If not using refs/pending/heads/* at all, or target ref is already set
-        # to pending, then push to the target ref directly.
-        retcode, output = RunGitWithCode(
-            ['push', '--porcelain', pushurl, 'HEAD:%s' % branch])
-        pushed_to_pending = pending_prefix and branch.startswith(pending_prefix)
-      else:
-        # Cherry-pick the change on top of pending ref and then push it.
-        assert branch.startswith('refs/'), branch
-        assert pending_prefix[-1] == '/', pending_prefix
-        pending_ref = pending_prefix + branch[len('refs/'):]
-        retcode, output = PushToGitPending(pushurl, pending_ref, branch)
-        pushed_to_pending = (retcode == 0)
-      if retcode == 0:
-        revision = RunGit(['rev-parse', 'HEAD']).strip()
+    remote, branch = cl.FetchUpstreamTuple(cl.GetBranch())
+    mirror = settings.GetGitMirror(remote)
+    pushurl = mirror.url if mirror else remote
+    pending_prefix = settings.GetPendingRefPrefix()
+    if not pending_prefix or branch.startswith(pending_prefix):
+      # If not using refs/pending/heads/* at all, or target ref is already set
+      # to pending, then push to the target ref directly.
+      retcode, output = RunGitWithCode(
+          ['push', '--porcelain', pushurl, 'HEAD:%s' % branch])
+      pushed_to_pending = pending_prefix and branch.startswith(pending_prefix)
     else:
-      # dcommit the merge branch.
-      cmd_args = [
-        'svn', 'dcommit',
-        '-C%s' % options.similarity,
-        '--no-rebase', '--rmdir',
-      ]
-      if settings.GetForceHttpsCommitUrl():
-        # Allow forcing https commit URLs for some projects that don't allow
-        # committing to http URLs (like Google Code).
-        remote_url = cl.GetGitSvnRemoteUrl()
-        if urlparse.urlparse(remote_url).scheme == 'http':
-          remote_url = remote_url.replace('http://', 'https://')
-        cmd_args.append('--commit-url=%s' % remote_url)
-      _, output = RunGitWithCode(cmd_args)
-      if 'Committed r' in output:
-        revision = re.match(
-          '.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1)
+      # Cherry-pick the change on top of pending ref and then push it.
+      assert branch.startswith('refs/'), branch
+      assert pending_prefix[-1] == '/', pending_prefix
+      pending_ref = pending_prefix + branch[len('refs/'):]
+      retcode, output = PushToGitPending(pushurl, pending_ref, branch)
+      pushed_to_pending = (retcode == 0)
+    if retcode == 0:
+      revision = RunGit(['rev-parse', 'HEAD']).strip()
     logging.debug(output)
   finally:
     # And then swap back to the original branch and clean up.
     RunGit(['checkout', '-q', cl.GetBranch()])
     RunGit(['branch', '-D', MERGE_BRANCH])
     if base_has_submodules:
       RunGit(['branch', '-D', CHERRY_PICK_BRANCH])
 
   if not revision:
     print('Failed to push. If this persists, please file a bug.')
@@ skipping 32 matching lines @@
       comment += ' (presubmit successful).'
     cl.RpcServer().add_comment(cl.GetIssue(), comment)
     cl.SetIssue(None)
 
   if pushed_to_pending:
     _, branch = cl.FetchUpstreamTuple(cl.GetBranch())
     print('The commit is in the pending queue (%s).' % pending_ref)
     print('It will show up on %s in ~1 min, once it gets a Cr-Commit-Position '
           'footer.' % branch)
 
-  hook = POSTUPSTREAM_HOOK_PATTERN % cmd
+  hook = POSTUPSTREAM_HOOK_PATTERN % 'land'
   if os.path.isfile(hook):
     RunCommand([hook, merge_base], error_ok=True)
 
   return 1 if killed else 0
 
 
 def WaitForRealCommit(remote, pushed_commit, local_base_ref, real_ref):
   print()
   print('Waiting for commit to be landed on %s...' % real_ref)
   print('(If you are impatient, you may Ctrl-C once without harm)')
@@ skipping 80 matching lines @@
   print('All attempts to push to pending ref failed.')
   return code, out
 
 
 def IsFatalPushFailure(push_stdout):
   """True if retrying push won't help."""
   return '(prohibited by Gerrit)' in push_stdout
 
 
 @subcommand.usage('[upstream branch to apply against]')
-def CMDdcommit(parser, args):
-  """Commits the current changelist via git-svn."""
-  if not settings.GetIsGitSvn():
-    if git_footers.get_footer_svn_id():
-      # If it looks like previous commits were mirrored with git-svn.
-      message = """This repository appears to be a git-svn mirror, but no
-upstream SVN master is set. You probably need to run 'git auto-svn' once."""
-    else:
-      message = """This doesn't appear to be an SVN repository.
-If your project has a true, writeable git repository, you probably want to run
-'git cl land' instead.
-If your project has a git mirror of an upstream SVN master, you probably need
-to run 'git svn init'.
-
-Using the wrong command might cause your commit to appear to succeed, and the
-review to be closed, without actually landing upstream. If you choose to
-proceed, please verify that the commit lands upstream as expected."""
-    print(message)
-    ask_for_data('[Press enter to dcommit or ctrl-C to quit]')
-  # TODO(tandrii): kill this post SVN migration with
-  # https://codereview.chromium.org/2076683002
-  print('WARNING: chrome infrastructure is migrating SVN repos to Git.\n'
-        'Please let us know of this project you are committing to:'
-        '    http://crbug.com/600451')
-  return SendUpstream(parser, args, 'dcommit')
-
-
-@subcommand.usage('[upstream branch to apply against]')
 def CMDland(parser, args):
   """Commits the current changelist via git."""
   if settings.GetIsGitSvn() or git_footers.get_footer_svn_id():
     print('This appears to be an SVN repository.')
     print('Are you sure you didn\'t mean \'git cl dcommit\'?')

[Michael Moss, 2016/08/15 15:26:32]

Change this too, maybe remove the get_footer_svn_id() check, and just check if
they have git-svn configured, and if so, suggest they undo it?

     print('(Ignore if this is the first commit after migrating from svn->git)')
     ask_for_data('[Press enter to push or ctrl-C to quit]')
-  return SendUpstream(parser, args, 'land')
+  return SendUpstream(parser, args)
 
 
 @subcommand.usage('<patch url or issue id or issue url>')
 def CMDpatch(parser, args):
   """Patches in a code review."""
   parser.add_option('-b', dest='newbranch',
                     help='create a new branch off trunk for the patch')
   parser.add_option('-f', '--force', action='store_true',
                     help='with -b, clobber any existing branch')
   parser.add_option('-d', '--directory', action='store', metavar='DIR',
@@ skipping 824 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   setup_color.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)