Remove SVN (and dcommit) support from git-cl

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 46 matching lines @@
 import rietveld
 import scm
 import subcommand
 import subprocess2
 import watchlists
 
 __version__ = '2.0'
 
 COMMIT_BOT_EMAIL = 'commit-bot@chromium.org'
 DEFAULT_SERVER = 'https://codereview.chromium.org'
-POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-%s'
+POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-land'
 DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
-GIT_INSTRUCTIONS_URL = 'http://code.google.com/p/chromium/wiki/UsingGit'
 REFS_THAT_ALIAS_TO_OTHER_REFS = {
     'refs/remotes/origin/lkgr': 'refs/remotes/origin/master',
     'refs/remotes/origin/lkcr': 'refs/remotes/origin/master',
 }
 
 # Valid extensions for files we want to lint.
 DEFAULT_LINT_REGEX = r"(.*\.cpp|.*\.cc|.*\.h)"
 DEFAULT_LINT_IGNORE_REGEX = r"$^"
 
 # Shortcut since it quickly becomes redundant.
@@ skipping 471 matching lines @@
         'failure_reason': build.get('failure_reason'),
         'url': build.get('url'),
     }
 
   converted = []
   for _, build in sorted(builds.items()):
       converted.append(convert_build_dict(build))
   write_json(output_file, converted)
 
 
-def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards):
-  """Return the corresponding git ref if |base_url| together with |glob_spec|
-  matches the full |url|.
-
-  If |allow_wildcards| is true, |glob_spec| can contain wildcards (see below).
-  """
-  fetch_suburl, as_ref = glob_spec.split(':')
-  if allow_wildcards:
-    glob_match = re.match('(.+/)?(\*|{[^/]*})(/.+)?', fetch_suburl)
-    if glob_match:
-      # Parse specs like "branches/*/src:refs/remotes/svn/*" or
-      # "branches/{472,597,648}/src:refs/remotes/svn/*".
-      branch_re = re.escape(base_url)
-      if glob_match.group(1):
-        branch_re += '/' + re.escape(glob_match.group(1))
-      wildcard = glob_match.group(2)
-      if wildcard == '*':
-        branch_re += '([^/]*)'
-      else:
-        # Escape and replace surrounding braces with parentheses and commas
-        # with pipe symbols.
-        wildcard = re.escape(wildcard)
-        wildcard = re.sub('^\\\\{', '(', wildcard)
-        wildcard = re.sub('\\\\,', '|', wildcard)
-        wildcard = re.sub('\\\\}$', ')', wildcard)
-        branch_re += wildcard
-      if glob_match.group(3):
-        branch_re += re.escape(glob_match.group(3))
-      match = re.match(branch_re, url)
-      if match:
-        return re.sub('\*$', match.group(1), as_ref)
-
-  # Parse specs like "trunk/src:refs/remotes/origin/trunk".
-  if fetch_suburl:
-    full_url = base_url + '/' + fetch_suburl
-  else:
-    full_url = base_url
-  if full_url == url:
-    return as_ref
-  return None
-
-
 def print_stats(similarity, find_copies, args):
   """Prints statistics about the change to the user."""
   # --no-ext-diff is broken in some versions of Git, so try to work around
   # this by overriding the environment (but there is still a problem if the
   # git config key "diff.external" is used).
   env = GetNoGitPagerEnv()
   if 'GIT_EXTERNAL_DIFF' in env:
     del env['GIT_EXTERNAL_DIFF']
 
   if find_copies:
@@ skipping 14 matching lines @@
 
 class BuildbucketResponseException(Exception):
   pass
 
 
 class Settings(object):
   def __init__(self):
     self.default_server = None
     self.cc = None
     self.root = None
-    self.is_git_svn = None
-    self.svn_branch = None
     self.tree_status_url = None
     self.viewvc_url = None
     self.updated = False
     self.is_gerrit = None
     self.squash_gerrit_uploads = None
     self.gerrit_skip_ensure_authenticated = None
     self.git_editor = None
     self.project = None
     self.force_https_commit_url = None
     self.pending_ref_prefix = None
@@ skipping 42 matching lines @@
     if not os.path.isdir(local_url):
       return None
     git_cache.Mirror.SetCachePath(os.path.dirname(local_url))
     remote_url = git_cache.Mirror.CacheDirToUrl(local_url)
     # Use the /dev/null print_func to avoid terminal spew in WaitForRealCommit.
     mirror = git_cache.Mirror(remote_url, print_func = lambda *args: None)
     if mirror.exists():
       return mirror
     return None
 
-  def GetIsGitSvn(self):
-    """Return true if this repo looks like it's using git-svn."""
-    if self.is_git_svn is None:
-      if self.GetPendingRefPrefix():
-        # If PENDING_REF_PREFIX is set then it's a pure git repo no matter what.
-        self.is_git_svn = False
-      else:
-        # If you have any "svn-remote.*" config keys, we think you're using svn.
-        self.is_git_svn = RunGitWithCode(
-            ['config', '--local', '--get-regexp', r'^svn-remote\.'])[0] == 0
-    return self.is_git_svn
-
-  def GetSVNBranch(self):
-    if self.svn_branch is None:
-      if not self.GetIsGitSvn():
-        DieWithError('Repo doesn\'t appear to be a git-svn repo.')
-
-      # Try to figure out which remote branch we're based on.
-      # Strategy:
-      # 1) iterate through our branch history and find the svn URL.
-      # 2) find the svn-remote that fetches from the URL.
-
-      # regexp matching the git-svn line that contains the URL.
-      git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE)
-
-      # We don't want to go through all of history, so read a line from the
-      # pipe at a time.
-      # The -100 is an arbitrary limit so we don't search forever.
-      cmd = ['git', 'log', '-100', '--pretty=medium']
-      proc = subprocess2.Popen(cmd, stdout=subprocess2.PIPE,
-                               env=GetNoGitPagerEnv())
-      url = None
-      for line in proc.stdout:
-        match = git_svn_re.match(line)
-        if match:
-          url = match.group(1)
-          proc.stdout.close()  # Cut pipe.
-          break
-
-      if url:
-        svn_remote_re = re.compile(r'^svn-remote\.([^.]+)\.url (.*)$')
-        remotes = RunGit(['config', '--get-regexp',
-                          r'^svn-remote\..*\.url']).splitlines()
-        for remote in remotes:
-          match = svn_remote_re.match(remote)
-          if match:
-            remote = match.group(1)
-            base_url = match.group(2)
-            rewrite_root = RunGit(
-                ['config', 'svn-remote.%s.rewriteRoot' % remote],
-                error_ok=True).strip()
-            if rewrite_root:
-              base_url = rewrite_root
-            fetch_spec = RunGit(
-                ['config', 'svn-remote.%s.fetch' % remote],
-                error_ok=True).strip()
-            if fetch_spec:
-              self.svn_branch = MatchSvnGlob(url, base_url, fetch_spec, False)
-              if self.svn_branch:
-                break
-            branch_spec = RunGit(
-                ['config', 'svn-remote.%s.branches' % remote],
-                error_ok=True).strip()
-            if branch_spec:
-              self.svn_branch = MatchSvnGlob(url, base_url, branch_spec, True)
-              if self.svn_branch:
-                break
-            tag_spec = RunGit(
-                ['config', 'svn-remote.%s.tags' % remote],
-                error_ok=True).strip()
-            if tag_spec:
-              self.svn_branch = MatchSvnGlob(url, base_url, tag_spec, True)
-              if self.svn_branch:
-                break
-
-      if not self.svn_branch:
-        DieWithError('Can\'t guess svn branch -- try specifying it on the '
-            'command line')
-
-    return self.svn_branch
-
   def GetTreeStatusUrl(self, error_ok=False):
     if not self.tree_status_url:
       error_message = ('You must configure your tree status URL by running '
                        '"git cl config".')
       self.tree_status_url = self._GetRietveldConfig(
           'tree-status-url', error_ok=error_ok, error_message=error_message)
     return self.tree_status_url
 
   def GetViewVCUrl(self):
     if not self.viewvc_url:
@@ skipping 330 matching lines @@
     upstream_branch = _git_get_branch_config_value('merge', branch=branch)
 
     if upstream_branch:
       remote = _git_get_branch_config_value('remote', branch=branch)
     else:
       upstream_branch = RunGit(['config', 'rietveld.upstream-branch'],
                                error_ok=True).strip()
       if upstream_branch:
         remote = RunGit(['config', 'rietveld.upstream-remote']).strip()
       else:
-        # Fall back on trying a git-svn upstream branch.
-        if settings.GetIsGitSvn():
-          upstream_branch = settings.GetSVNBranch()
+        # Else, try to guess the origin remote.
+        remote_branches = RunGit(['branch', '-r']).split()
+        if 'origin/master' in remote_branches:
+          # Fall back on origin/master if it exits.
+          remote = 'origin'
+          upstream_branch = 'refs/heads/master'
         else:
-          # Else, try to guess the origin remote.
-          remote_branches = RunGit(['branch', '-r']).split()
-          if 'origin/master' in remote_branches:
-            # Fall back on origin/master if it exits.
-            remote = 'origin'
-            upstream_branch = 'refs/heads/master'
-          elif 'origin/trunk' in remote_branches:
-            # Fall back on origin/trunk if it exists. Generally a shared
-            # git-svn clone
-            remote = 'origin'
-            upstream_branch = 'refs/heads/trunk'
-          else:
-            DieWithError(
-               'Unable to determine default branch to diff against.\n'
-               'Either pass complete "git diff"-style arguments, like\n'
-               '  git cl upload origin/master\n'
-               'or verify this branch is set up to track another \n'
-               '(via the --track argument to "git checkout -b ...").')
+          DieWithError(
+             'Unable to determine default branch to diff against.\n'
+             'Either pass complete "git diff"-style arguments, like\n'
+             '  git cl upload origin/master\n'
+             'or verify this branch is set up to track another \n'
+             '(via the --track argument to "git checkout -b ...").')
 
     return remote, upstream_branch
 
   def GetCommonAncestorWithUpstream(self):
     upstream_branch = self.GetUpstreamBranch()
     if not BranchExists(upstream_branch):
       DieWithError('The upstream for the current branch (%s) does not exist '
                    'anymore.\nPlease fix it and try again.' % self.GetBranch())
     return git_common.get_or_create_merge_base(self.GetBranch(),
                                                upstream_branch)
@@ skipping 18 matching lines @@
         remote, branch = self.FetchUpstreamTuple(branch)
         branch = ShortBranchName(branch)
         if remote != '.' or branch.startswith('refs/remotes'):
           break
       else:
         remotes = RunGit(['remote'], error_ok=True).split()
         if len(remotes) == 1:
           remote, = remotes
         elif 'origin' in remotes:
           remote = 'origin'
-          logging.warning('Could not determine which remote this change is '
-                          'associated with, so defaulting to "%s".  This may '
-                          'not be what you want.  You may prevent this message '
-                          'by running "git svn info" as documented here:  %s',
-                          self._remote,
-                          GIT_INSTRUCTIONS_URL)
+          logging.warn('Could not determine which remote this change is '
+                       'associated with, so defaulting to "%s".' % self._remote)
         else:
           logging.warn('Could not determine which remote this change is '
-                       'associated with.  You may prevent this message by '
-                       'running "git svn info" as documented here:  %s',
-                       GIT_INSTRUCTIONS_URL)
+                       'associated with.')
         branch = 'HEAD'
       if branch.startswith('refs/remotes'):
         self._remote = (remote, branch)
       elif branch.startswith('refs/branch-heads/'):
         self._remote = (remote, branch.replace('refs/', 'refs/remotes/'))
       else:
         self._remote = (remote, 'refs/remotes/%s/%s' % (remote, branch))
     return self._remote
 
   def GitSanityChecks(self, upstream_git_obj):
@@ skipping 38 matching lines @@
       return False
     return True
 
   def GetGitBaseUrlFromConfig(self):
     """Return the configured base URL from branch.<branchname>.baseurl.
 
     Returns None if it is not set.
     """
     return self._GitGetBranchConfigValue('base-url')
 
-  def GetGitSvnRemoteUrl(self):
-    """Return the configured git-svn remote URL parsed from git svn info.
-
-    Returns None if it is not set.
-    """
-    # URL is dependent on the current directory.
-    data = RunGit(['svn', 'info'], cwd=settings.GetRoot())
-    if data:
-      keys = dict(line.split(': ', 1) for line in data.splitlines()
-                  if ': ' in line)
-      return keys.get('URL', None)
-    return None
-
   def GetRemoteUrl(self):
     """Return the configured remote URL, e.g. 'git://example.org/foo.git/'.
 
     Returns None if there is no remote.
     """
     remote, _ = self.GetRemoteBranch()
     url = RunGit(['config', 'remote.%s.url' % remote], error_ok=True).strip()
 
     # If URL is pointing to a local directory, it is probably a git cache.
     if os.path.isdir(url):
@@ skipping 750 matching lines @@
       upload_args.append('--private')
 
     upload_args.extend(['--git_similarity', str(options.similarity)])
     if not options.find_copies:
       upload_args.extend(['--git_no_find_copies'])
 
     # Include the upstream repo's URL in the change -- this is useful for
     # projects that have their source spread across multiple repos.
     remote_url = self.GetGitBaseUrlFromConfig()
     if not remote_url:
-      if settings.GetIsGitSvn():
-        remote_url = self.GetGitSvnRemoteUrl()
-      else:
-        if self.GetRemoteUrl() and '/' in self.GetUpstreamBranch():
-          remote_url = '%s@%s' % (self.GetRemoteUrl(),
-                                  self.GetUpstreamBranch().split('/')[-1])
+      if self.GetRemoteUrl() and '/' in self.GetUpstreamBranch():
+        remote_url = '%s@%s' % (self.GetRemoteUrl(),
+                                self.GetUpstreamBranch().split('/')[-1])
     if remote_url:
       remote, remote_branch = self.GetRemoteBranch()
       target_ref = GetTargetRef(remote, remote_branch, options.target_branch,
                                 settings.GetPendingRefPrefix())
       if target_ref:
         upload_args.extend(['--target_ref', target_ref])
 
       # Look for dependent patchsets. See crbug.com/480453 for more details.
       remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
       upstream_branch = ShortBranchName(upstream_branch)
@@ skipping 1917 matching lines @@
   if options.cq_dry_run and options.use_commit_queue:
     parser.error('only one of --use-commit-queue and --cq-dry-run allowed.')
 
   # For sanity of test expectations, do this otherwise lazy-loading *now*.
   settings.GetIsGerrit()
 
   cl = Changelist(auth_config=auth_config, codereview=options.forced_codereview)
   return cl.CMDUpload(options, args, orig_args)
 
 
-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
 
   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.
@@ skipping 33 matching lines @@
           '"Forge-Author" permission.')
     if not cl.GetIssue():
       DieWithError('You must upload the issue first to Gerrit.\n'
                    '  If you would rather have `git cl land` upload '
                    'automatically for you, see http://crbug.com/642759')
     return cl._codereview_impl.CMDLand(options.force, options.bypass_hooks,
                                        options.verbose)
 
   current = cl.GetBranch()
   remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
-  if not settings.GetIsGitSvn() and remote == '.':
+  if remote == '.':
     print()
     print('Attempting to push branch %r into another local branch!' % current)
     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('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:
-    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 20 matching lines @@
 
   print('Description:')
   print(commit_desc.description)
 
   branches = [merge_base, cl.GetBranchRef()]
   if not options.force:
     print_stats(options.similarity, options.find_copies, branches)
 
   # We want to squash all this branch's commits into one commit with the proper
   # description. We do this by doing a "reset --soft" to the base branch (which
-  # keeps the working copy the same), then dcommitting that.  If origin/master
-  # has a submodule merge commit, we'll also need to cherry-pick the squashed
-  # commit onto a branch based on the git-svn head.
+  # keeps the working copy the same), then dcommitting that.
   MERGE_BRANCH = 'git-cl-commit'
   CHERRY_PICK_BRANCH = 'git-cl-cherry-pick'
   # Delete the branches if they exist.
   for branch in [MERGE_BRANCH, CHERRY_PICK_BRANCH]:
     showref_cmd = ['show-ref', '--quiet', '--verify', 'refs/heads/%s' % branch]
     result = RunGitWithCode(showref_cmd)
     if result[0] == 0:
       RunGit(['branch', '-D', branch])
 
   # We might be in a directory that's present in this branch but not in the
@@ skipping 14 matching lines @@
     RunGit(['checkout', '-q', '-b', MERGE_BRANCH])
     RunGit(['reset', '--soft', merge_base])
     if options.contributor:
       RunGit(
           [
             '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)
-        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)
+      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.')
     return 1
 
   killed = False
   if pushed_to_pending:
     try:
       revision = WaitForRealCommit(remote, revision, base_branch, branch)
       # We set pushed_to_pending to False, since it made it all the way to the
@@ skipping 24 matching lines @@
     else:
       comment += ' (presubmit successful).'
     cl.RpcServer().add_comment(cl.GetIssue(), comment)
 
   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
   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 81 matching lines @@
   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 we
-don't support git-svn mirrors anymore."""
-    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]')
-  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')
+  """DEPRECATED: Used to commit the current changelist via git-svn."""
+  message = ('git-cl no longer supports committing to SVN repositories via'
+             'git-svn. You probably want to use `git cl land` instead.')
+  print(message)

[tandrii(chromium), 2016/10/06 08:04:01]

I'd add return 1 so command results in error.

[agable, 2016/10/06 21:43:15]

Done.

 
 
 @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\'?')
-    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')
 
 
 @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')
@@ skipping 73 matching lines @@
       parser.error('--reject is not supported with Gerrit codereview.')
     if options.nocommit:
       parser.error('--nocommit is not supported with Gerrit codereview.')
     if options.directory:
       parser.error('--directory is not supported with Gerrit codereview.')
 
   return cl.CMDPatchIssue(args[0], options.reject, options.nocommit,
                           options.directory)
 
 
-def CMDrebase(parser, args):
-  """Rebases current branch on top of svn repo."""
-  # Provide a wrapper for git svn rebase to help avoid accidental
-  # git svn dcommit.
-  # It's the only command that doesn't use parser at all since we just defer
-  # execution to git-svn.
-
-  return RunGitWithCode(['svn', 'rebase'] + args)[1]
-
-
 def GetTreeStatus(url=None):
   """Fetches the tree status and returns either 'open', 'closed',
   'unknown' or 'unset'."""
   url = url or settings.GetTreeStatusUrl(error_ok=True)
   if url:
     status = urllib2.urlopen(url).read().lower()
     if status.find('closed') != -1 or status == '0':
       return 'closed'
     elif status.find('open') != -1 or status == '1':
       return 'open'
@@ skipping 752 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)