Remove more logic out of trychange.py into scm.py.

scm.py

 # Copyright (c) 2006-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.
 
 """SCM-specific utility classes."""
 
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import xml.dom.minidom
 
 import gclient_utils
 
+def ValidateEmail(email):
+ return (re.match(r"^[a-zA-Z0-9._%-+]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$", email)
+         is not None)
+
 
 class GIT(object):
   COMMAND = "git"
 
   @staticmethod
   def Capture(args, in_directory=None, print_error=True, error_ok=False):
     """Runs git, capturing output sent to stdout as a string.
 
     Args:
       args: A sequence of command line parameters to be passed to git.
@@ skipping 44 matching lines @@
     return GIT.Capture(['config', 'user.email'],
                        repo_root, error_ok=True).strip()
 
   @staticmethod
   def ShortBranchName(branch):
     """Converts a name like 'refs/heads/foo' to just 'foo'."""
     return branch.replace('refs/heads/', '')
 
   @staticmethod
   def GetBranchRef(cwd):
+    """Returns the full branch reference, e.g. 'refs/heads/master'."""
+    return GIT.Capture(['symbolic-ref', 'HEAD'], cwd).strip()
+
+  @staticmethod
+  def GetBranch(cwd):
     """Returns the short branch name, e.g. 'master'."""
-    return GIT.Capture(['symbolic-ref', 'HEAD'], cwd).strip()
+    return GIT.ShortBranchName(GIT.BranchRef(cwd))
 
   @staticmethod
   def IsGitSvn(cwd):
     """Returns true if this repo looks like it's using git-svn."""
     # If you have any "svn-remote.*" config keys, we think you're using svn.
     try:
       GIT.Capture(['config', '--get-regexp', r'^svn-remote\.'], cwd)
       return True
     except gclient_utils.CheckCallError:
       return False
@@ skipping 40 matching lines @@
             proc.stdout.close()  # Cut pipe.
             break
     return svn_branch
 
   @staticmethod
   def FetchUpstreamTuple(cwd):
     """Returns a tuple containg remote and remote ref,
        e.g. 'origin', 'refs/heads/master'
     """
     remote = '.'
-    branch = GIT.ShortBranchName(GIT.GetBranchRef(cwd))
+    branch = GIT.GetBranch(cwd)
     upstream_branch = None
     upstream_branch = GIT.Capture(
         ['config', 'branch.%s.merge' % branch], error_ok=True).strip()
     if upstream_branch:
       remote = GIT.Capture(
           ['config', 'branch.%s.remote' % branch],
           error_ok=True).strip()
     else:
       # Fall back on trying a git-svn upstream branch.
       if GIT.IsGitSvn(cwd):
@@ skipping 20 matching lines @@
       branch = GIT.GetUpstream(cwd)
     diff = GIT.Capture(['diff-tree', '-p', '--no-prefix', branch, 'HEAD'],
                        cwd).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)
 
+  @staticmethod
+  def GetPatchName(cwd):
+    """Constructs a name for this patch."""
+    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd).strip()
+    return "%s-%s" % (GIT.GetBranch(cwd), short_sha)
+
+  @staticmethod
+  def GetCheckoutRoot(cwd):
+    """Returns the top level directory of the current repository.
+
+    The directory is returned as an absolute path.
+    """
+    return os.path.abspath(GIT.Capture(['rev-parse', '--show-cdup'],
+                                       cwd).strip())
+
 
 class SVN(object):
   COMMAND = "svn"
 
   @staticmethod
   def Run(args, in_directory):
     """Runs svn, sending output to stdout.
 
     Args:
       args: A sequence of command line parameters to be passed to svn.
@@ skipping 442 matching lines @@
     if not cur_dir_repo_root:
       return None
 
     while True:
       parent = os.path.dirname(directory)
       if (SVN.CaptureInfo(parent, print_error=False).get(
               "Repository Root") != cur_dir_repo_root):
         break
       directory = parent
     return directory