Support getting changes of non-HEAD branches

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 distutils.version import LooseVersion
@@ skipping 810 matching lines @@
     return RunGit(['config', param], **kwargs).strip()
 
 
 def ShortBranchName(branch):
   """Convert a name like 'refs/heads/foo' to just 'foo'."""
   return branch.replace('refs/heads/', '', 1)
 
 
 def GetCurrentBranchRef():
   """Returns branch ref (e.g., refs/heads/master) or None."""
-  return RunGit(['symbolic-ref', 'HEAD'],
-                stderr=subprocess2.VOID, error_ok=True).strip() or None
+  ref = RunGit(['symbolic-ref', 'HEAD'],
+               stderr=subprocess2.VOID, error_ok=True).strip() or None
+  if ref and not ref.startswith('refs/heads/'):
+    ref = 'refs/heads/'+ref
+  return ref
 
 
 def GetCurrentBranch():
   """Returns current branch or None.
 
   For refs/heads/* branches, returns just last part. For others, full ref.
   """
   branchref = GetCurrentBranchRef()
   if branchref:
     return ShortBranchName(branchref)
@@ skipping 262 matching lines @@
                        GIT_INSTRUCTIONS_URL)
         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):
+  def GitSanityChecks(self, upstream_git_obj, local_ref='HEAD'):
     """Checks git repo status and ensures diff is from local commits."""
 
     if upstream_git_obj is None:
       if self.GetBranch() is None:
         print >> sys.stderr, (
             'ERROR: unable to determine current branch (detached HEAD?)')
       else:
         print >> sys.stderr, (
             'ERROR: no upstream branch')
       return False
 
     # Verify the commit we're diffing against is in our current branch.
     upstream_sha = RunGit(['rev-parse', '--verify', upstream_git_obj]).strip()
-    common_ancestor = RunGit(['merge-base', upstream_sha, 'HEAD']).strip()
-    if upstream_sha != common_ancestor:
+    common_anc = RunGit(['merge-base', upstream_sha, local_ref]).strip()
+    if upstream_sha != common_anc:
       print >> sys.stderr, (
           'ERROR: %s is not in the current branch.  You may need to rebase '
           'your tracking branch' % upstream_sha)
       return False
 
     # List the commits inside the diff, and verify they are all local.
     commits_in_diff = RunGit(
-        ['rev-list', '^%s' % upstream_sha, 'HEAD']).splitlines()
+        ['rev-list', '^%s' % upstream_sha, local_ref]).splitlines()
     code, remote_branch = RunGitWithCode(['config', 'gitcl.remotebranch'])
     remote_branch = remote_branch.strip()
     if code != 0:
       _, remote_branch = self.GetRemoteBranch()
 
     commits_in_remote = RunGit(
         ['rev-list', '^%s' % upstream_sha, remote_branch]).splitlines()
 
     common_commits = set(commits_in_diff) & set(commits_in_remote)
     if common_commits:
@@ skipping 102 matching lines @@
       if codereview_server:
         RunGit(['config', codereview_setting, codereview_server])
     else:
       current_issue = self.GetIssue()
       if current_issue:
         RunGit(['config', '--unset', issue_setting])
       self.issue = None
       self.SetPatchset(None)
 
   def GetChange(self, upstream_branch, author):
-    if not self.GitSanityChecks(upstream_branch):
+    local_ref = self.GetBranchRef()
+    if not self.GitSanityChecks(upstream_branch, local_ref):
       DieWithError('\nGit sanity check failure')
 
     root = settings.GetRelativeRoot()
     if not root:
       root = '.'
     absroot = os.path.abspath(root)
 
     # We use the sha1 of HEAD as a name of this change.
-    name = RunGitWithCode(['rev-parse', 'HEAD'])[1].strip()
+    name = RunGitWithCode(['rev-parse', local_ref])[1].strip()
     # Need to pass a relative path for msysgit.
     try:
-      files = scm.GIT.CaptureStatus([root], '.', upstream_branch)
+      files = scm.GIT.CaptureStatus([root], '.', upstream_branch, local_ref)
     except subprocess2.CalledProcessError:
       DieWithError(
           ('\nFailed to diff against upstream branch %s\n\n'
            'This branch probably doesn\'t exist anymore. To reset the\n'
            'tracking branch, please run\n'
            '    git branch --set-upstream %s trunk\n'
            'replacing trunk with origin/master or the relevant branch') %
           (upstream_branch, self.GetBranch()))
 
     issue = self.GetIssue()
     patchset = self.GetPatchset()
     if issue:
       description = self.GetDescription()
     else:
       # If the change was never uploaded, use the log messages of all commits
       # up to the branch point, as git cl upload will prefill the description
       # with these log messages.
-      args = ['log', '--pretty=format:%s%n%n%b', '%s...' % (upstream_branch)]
+      args = ['log', '--pretty=format:%s%n%n%b',
+              '%s...%s' % (upstream_branch, local_ref)]
       description = RunGitWithCode(args)[1].strip()
 
     if not author:
       author = RunGit(['config', 'user.email']).strip() or None
     return presubmit_support.GitChange(
         name,
         description,
         absroot,
         files,
         issue,
         patchset,
         author,
-        upstream=upstream_branch)
+        upstream=upstream_branch,
+        local_ref=local_ref)
 
   def UpdateDescription(self, description):
     self.description = description
     return self._codereview_impl.UpdateDescriptionRemote(description)
 
   def RunHook(self, committing, may_prompt, verbose, change):
     """Calls sys.exit() if the hook fails; returns a HookResults otherwise."""
     try:
       return presubmit_support.DoPresubmitChecks(change, committing,
           verbose=verbose, output_stream=sys.stdout, input_stream=sys.stdin,
@@ skipping 3505 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)