Remove gclient-specific hacks from trychange into gcl.

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
 import getpass
 import logging
 import optparse
 import os
 import shutil
 import socket
 import subprocess
 import sys
 import tempfile
 import urllib
 
 import breakpad
 
 import gcl
 import gclient_utils
 import scm
 import presubmit_support
-import upload
 
-__version__ = '1.1.2'
+__version__ = '1.2'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
 USAGE = r"""%prog [change_name] [options]
 
 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.
 
@@ skipping 18 matching lines @@
 class InvalidScript(Exception):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
 class NoTryServerAccess(Exception):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
-def PathDifference(root, subpath):
-  """Returns the difference subpath minus root."""
-  if subpath.find(root) != 0:
-    return None
-  # If the root does not have a trailing \ or /, we add it so the returned path
-  # starts immediately after the seperator regardless of whether it is provided.
-  if not root.endswith(os.sep):
-    root += os.sep
-  return subpath[len(root):]
-
-
-def GetSourceRoot():
-  """Returns the absolute directory one level up from the repository root."""
-  # TODO(maruel): This is odd to assume that '..' is the source root.
-  return os.path.abspath(os.path.join(gcl.GetRepositoryRoot(), '..'))
-
-
 def GetTryServerSettings():
   """Grab try server settings local to the repository."""
   def _SafeResolve(host):
     try:
       return socket.getaddrinfo(host, None)
     except socket.gaierror:
       return None
 
   settings = {}
   settings['http_port'] = gcl.GetCodeReviewSetting('TRYSERVER_HTTP_PORT')
@@ skipping 21 matching lines @@
 
 def EscapeDot(name):
   return name.replace('.', '-')
 
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
   def __init__(self, options):
     self.options = options
 
-  def ProcessOptions(self):
-    raise NotImplementedError
+  def GetFileNames(self):
+    """Return the list of files in the diff."""
+    return self.options.files
 
 
 class SVN(SCM):
   """Gathers the options and diff for a subversion checkout."""
-  def GenerateDiff(self, files, root):
+  def __init__(self, *args, **kwargs):
+    SCM.__init__(self, *args, **kwargs)
+    self.checkout_root = scm.SVN.GetCheckoutRoot(os.getcwd())
+    self.options.files
+    if not self.options.diff:
+      # Generate the diff from the scm.
+      self.options.diff = self._GenerateDiff()
+    if not self.options.email:
+      # Assumes the svn credential is an email address.
+      self.options.email = scm.SVN.GetEmail(self.checkout_root)
+
+  def _GenerateDiff(self):
     """Returns a string containing the diff for the given file list.
 
     The files in the list should either be absolute paths or relative to the
-    given root. If no root directory is provided, the repository root will be
-    used.
+    given root.
     """
     previous_cwd = os.getcwd()
-    os.chdir(root or scm.SVN.GetCheckoutRoot(previous_cwd))
-
+    os.chdir(self.checkout_root)
+    if not self.options.files:
+      self.options.files = [f[1] for f in scm.SVN.CaptureStatus(None)]
     # Directories will return None so filter them out.
-    diff = filter(None, [scm.SVN.DiffItem(f) for f in files])
+    diff = filter(None, [scm.SVN.DiffItem(f) for f in self.options.files])
     os.chdir(previous_cwd)
     return "".join(diff)
 
-  def GetFileNames(self):
-    """Return the list of files in the diff."""
-    return self.change_info.GetFileNames()
-
   def GetLocalRoot(self):
     """Return the path of the repository root."""
-    return self.change_info.GetLocalRoot()
-
-  def ProcessOptions(self):
-    checkout_root = None
-    if not self.options.diff:
-      # Generate the diff with svn and write it to the submit queue path.  The
-      # files are relative to the repository root, but we need patches relative
-      # to one level up from there (i.e., 'src'), so adjust both the file
-      # paths and the root of the diff.
-      # TODO(maruel): Remove this hack.
-      source_root = GetSourceRoot()
-      checkout_root = scm.SVN.GetCheckoutRoot(os.getcwd())
-      prefix = PathDifference(source_root, checkout_root)
-      adjusted_paths = [os.path.join(prefix, x) for x in self.options.files]
-      self.options.diff = self.GenerateDiff(adjusted_paths, root=source_root)
-      self.change_info = gcl.LoadChangelistInfoForMultiple(self.options.name,
-          gcl.GetRepositoryRoot(), True, True)
-    if not self.options.email:
-      checkout_root = checkout_root or scm.SVN.GetCheckoutRoot(os.getcwd())
-      self.options.email = scm.SVN.GetEmail(checkout_root)
+    return self.checkout_root
 
 
 class GIT(SCM):
   """Gathers the options and diff for a git checkout."""
-  def GenerateDiff(self):
+  def __init__(self, *args, **kwargs):
+    SCM.__init__(self, *args, **kwargs)
+    self.checkout_root = os.path.abspath(
+        gclient_utils.CheckCall(['git', 'rev-parse', '--show-cdup']).strip())
+    if not self.options.diff:
+      self.options.diff = self._GenerateDiff()
+    if not self.options.name:
+      self.options.name = self._GetPatchName()
+    if not self.options.email:
+      self.options.email = scm.GIT.GetEmail('.')
+
+  def _GenerateDiff(self):
     """Get the diff we'll send to the try server. We ignore the files list."""
-    branch = upload.RunShell(['git', 'cl', 'upstream']).strip()
-    diff = upload.RunShell(['git', 'diff-tree', '-p', '--no-prefix',
-                            branch, 'HEAD']).splitlines(True)
+    branch = gclient_utils.CheckCall(['git', 'cl', 'upstream']).strip()
+    diff = gclient_utils.CheckCall(['git', 'diff-tree', '-p', '--no-prefix',
+                                    branch, 'HEAD']).splitlines(True)
     for i in range(len(diff)):
       # In the case of added files, replace /dev/null with the path to the
       # file being added.
       if diff[i].startswith('--- /dev/null'):
         diff[i] = '--- %s' % diff[i+1][4:]
     return ''.join(diff)
 
-  def GetFileNames(self):
-    """Return the list of files in the diff."""
-    return self.options.files
-
-  def GetLocalRoot(self):
-    """Return the path of the repository root."""
-    # TODO: check for errors here?
-    root = upload.RunShell(['git', 'rev-parse', '--show-cdup']).strip()
-    return os.path.abspath(root)
-
-  def GetPatchName(self):
+  def _GetPatchName(self):
     """Construct a name for this patch."""
     # TODO: perhaps include the hash of the current commit, to distinguish
     # patches?
-    branch = upload.RunShell(['git', 'symbolic-ref', 'HEAD']).strip()
+    branch = gclient_utils.CheckCall(['git', 'symbolic-ref', 'HEAD']).strip()
     if not branch.startswith('refs/heads/'):
       # TODO(maruel): Find a better type.
       raise NoTryServerAccess("Couldn't figure out branch name")
     branch = branch[len('refs/heads/'):]
     return branch
 
-  def ProcessOptions(self):
-    if not self.options.diff:
-      self.options.diff = self.GenerateDiff()
-    if not self.options.name:
-      self.options.name = self.GetPatchName()
-    if not self.options.email:
-      self.options.email = scm.GIT.GetEmail('.')
+  def GetLocalRoot(self):
+    """Return the path of the repository root."""
+    return self.checkout_root
 
 
 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 130 matching lines @@
   """
   __pychecker__ = 'no-returnvalues'
   # Subversion has a .svn in all working directories.
   if os.path.isdir('.svn'):
     logging.info("Guessed VCS = Subversion")
     return SVN(options)
 
   # 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:
-    out, returncode = subprocess.Popen(
-        ["git", "rev-parse", "--is-inside-work-tree"],
-        shell=sys.platform.startswith('win'),
-        stdout=subprocess.PIPE).communicate()[0]
-    if returncode == 0:
-      logging.info("Guessed VCS = Git")
-      return GIT(options)
-  except OSError, (errno, message):
-    if errno != 2:  # ENOENT -- they don't have git installed.
+    gclient_utils.CheckCall(["git", "rev-parse", "--is-inside-work-tree"])
+    logging.info("Guessed VCS = Git")
+    return GIT(options)
+  except gclient_utils.CheckCallError, e:
+    if e.retcode != 2:  # ENOENT -- they don't have git installed.
       raise
-
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
 
 def TryChange(argv,
               file_list,
               swallow_exception,
               prog=None):
   """
   Args:
@@ skipping 124 matching lines @@
 
   try:
     # Convert options.diff into the content of the diff.
     if options.url:
       options.diff = urllib.urlopen(options.url).read()
     elif options.diff:
       options.diff = gclient_utils.FileRead(options.diff, 'rb')
     # Process the VCS in any case at least to retrieve the email address.
     try:
       options.scm = GuessVCS(options)
-      options.scm.ProcessOptions()
     except NoTryServerAccess, e:
       # If we got the diff, we don't care.
       if not options.diff:
         # TODO(maruel): Raise what?
         raise
 
     # Get try slaves from PRESUBMIT.py files if not specified.
     if not options.bot:
       if options.url:
         parser.error('You need to specify which bots to use.')
@@ skipping 23 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))