Add "diff against" support when sending try patches.

trychange.py

 #!/usr/bin/python
 # Copyright (c) 2009 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.
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
 import datetime
@@ skipping 56 matching lines @@
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
 def EscapeDot(name):
   return name.replace('.', '-')
 
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
-  def __init__(self, options, cwd):
-    self.checkout_root = cwd
+  def __init__(self, options, path):
+    items = path.split('@')
+    assert len(items) <= 2
+    self.checkout_root = items[0]
+    items.append(None)
+    self.diff_against = items[1]
     self.options = options
     self.files = self.options.files
     self.options.files = None
     self.codereview_settings = None
     self.codereview_settings_file = 'codereview.settings'
 
   def GetFileNames(self):
     """Return the list of files in the diff."""
     return self.files
 
@@ skipping 80 matching lines @@
     """
     if not self.files:
       previous_cwd = os.getcwd()
       os.chdir(self.checkout_root)
       excluded = ['!', '?', 'X', ' ', '~']
       self.files = [
           f[1] for f in scm.SVN.CaptureStatus(self.checkout_root)
           if f[0][0] not in excluded
       ]
       os.chdir(previous_cwd)
-    return scm.SVN.GenerateDiff(self.files, self.checkout_root, full_move=True)
+    return scm.SVN.GenerateDiff(self.files, self.checkout_root, full_move=True,
+                                revision=self.diff_against)
 
 
 class GIT(SCM):
   """Gathers the options and diff for a git checkout."""
   def __init__(self, *args, **kwargs):
     SCM.__init__(self, *args, **kwargs)
     self.checkout_root = scm.GIT.GetCheckoutRoot(self.checkout_root)
     if not self.options.name:
       self.options.name = scm.GIT.GetPatchName(self.checkout_root)
     if not self.options.email:
       self.options.email = scm.GIT.GetEmail(self.checkout_root)
     logging.info("GIT(%s)" % self.checkout_root)
 
   def ReadRootFile(self, filename):
     try:
       # A git checkout is always a full checkout.
       data = gclient_utils.FileRead(os.path.join(self.checkout_root, filename))
       logging.debug('%s:\n%s' % (filename, data))
       return data
     except (IOError, OSError):
       logging.debug('%s:\nNone' % filename)
       return None
 
   def GenerateDiff(self):
     # For now, ignores self.files
-    return scm.GIT.GenerateDiff(self.checkout_root, full_move=True)
+    return scm.GIT.GenerateDiff(self.checkout_root, full_move=True,
+                                branch=self.diff_against)
 
 
 def _ParseSendChangeOptions(options):
   """Parse common options passed to _SendChangeHTTP and _SendChangeSVN."""
   values = {}
   if options.email:
     values['email'] = options.email
   values['user'] = options.user
   values['name'] = options.name
   if options.bot:
@@ skipping 142 matching lines @@
   support it yet.
 
   This examines the path directory, guesses which SCM we're using, and
   returns an instance of the appropriate class.  Exit with an error if we can't
   figure it out.
 
   Returns:
     A SCM instance. Exits if the SCM can't be guessed.
   """
   __pychecker__ = 'no-returnvalues'
+  real_path = path.split('@')[0]
   logging.info("GuessVCS(%s)" % path)
   # Subversion has a .svn in all working directories.
-  if os.path.isdir(os.path.join(path, '.svn')):
+  if os.path.isdir(os.path.join(real_path, '.svn')):
     return SVN(options, path)
 
   # Git has a command to test if you're in a git tree.
   # Try running it, but don't die if we don't have git installed.
   try:
     gclient_utils.CheckCall(["git", "rev-parse", "--is-inside-work-tree"],
-                            path)
+                            real_path)
     return GIT(options, path)
   except gclient_utils.CheckCallError, e:
     if e.retcode != errno.ENOENT and e.retcode != 128:
       # ENOENT == 2 = they don't have git installed.
       # 128 = git error code when not in a repo.
       logging.warn(e.retcode)
       raise
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
@@ skipping 69 matching lines @@
                    help="File containing the diff to try")
   group.add_option("--url",
                    help="Url where to grab a patch")
   group.add_option("--root",
                    help="Root to use for the patch; base subdirectory for "
                         "patch created in a subdirectory")
   group.add_option("-p", "--patchlevel", type='int', metavar="LEVEL",
                    help="Used as -pN parameter to patch")
   group.add_option("-s", "--sub_rep", action="append", default=[],
                    help="Subcheckout to use in addition. This is mainly "
-                        "useful for gclient-style checkouts.")
+                        "useful for gclient-style checkouts. Use @rev or "
+                        "@branch or @branch1..branch2 to specify the "
+                        "revision/branch to diff against.")
   group.add_option("--no_gclient", action="store_true",
                    help="Disable automatic search for gclient checkout.")
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Access the try server by HTTP")
   group.add_option("--use_http",
                    action="store_const",
                    const=_SendChangeHTTP,
                    dest="send_patch",
                    help="Use HTTP to talk to the try server [default]")
@@ skipping 124 matching lines @@
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return 1
     print e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(TryChange(None, [], False))