Revert 32057, 32058, 32059, 32062 because they still have unwanted side-effects.

presubmit_support.py

 #!/usr/bin/python
 # 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
-__version__ = '1.3.4'
+__version__ = '1.3.3'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
 # change). We should add it as our presubmit scripts start feeling slow.
 
 import cPickle  # Exposed through the API.
 import cStringIO  # Exposed through the API.
 import exceptions
 import fnmatch
 import glob
 import logging
 import marshal  # Exposed through the API.
 import optparse
 import os  # Somewhat exposed through the API.
 import pickle  # Exposed through the API.
 import random
 import re  # Exposed through the API.
 import subprocess  # Exposed through the API.
 import sys  # Parts exposed through API.
 import tempfile  # Exposed through the API.
 import time
 import traceback  # Exposed through the API.
 import types
 import unittest  # Exposed through the API.
 import urllib2  # Exposed through the API.
 import warnings
 
 # Local imports.
+# TODO(joi) Would be cleaner to factor out utils in gcl to separate module, but
+# for now it would only be a couple of functions so hardly worth it.
 import gcl
-import gclient_utils
+import gclient_scm
 import presubmit_canned_checks
-import scm
 
 
 # Ask for feedback only once in program lifetime.
 _ASKED_FOR_FEEDBACK = False
 
 
 class NotImplementedException(Exception):
   """We're leaving placeholders in a bunch of places to remind us of the
   design of the API, but we have not implemented all of it yet. Implement as
   the need arises.
@@ skipping 181 matching lines @@
 
     Args:
       Depot path as a string.
 
     Returns:
       The local path of the depot path under the user's current client, or None
       if the file is not mapped.
 
       Remember to check for the None case and show an appropriate error!
     """
-    local_path = scm.SVN.CaptureInfo(depot_path).get('Path')
+    local_path = gclient_scm.CaptureSVNInfo(depot_path).get('Path')
     if local_path:
       return local_path
 
   def LocalToDepotPath(self, local_path):
     """Translate a local path to a depot path.
 
     Args:
       Local path (relative to current directory, or absolute) as a string.
 
     Returns:
       The depot path (SVN URL) of the file if mapped, otherwise None.
     """
-    depot_path = scm.SVN.CaptureInfo(local_path).get('URL')
+    depot_path = gclient_scm.CaptureSVNInfo(local_path).get('URL')
     if depot_path:
       return depot_path
 
   def AffectedFiles(self, include_dirs=False, include_deletes=True):
     """Same as input_api.change.AffectedFiles() except only lists files
     (and optionally directories) in the same directory as the current presubmit
     script, or subdirectories thereof.
     """
     dir_with_slash = normpath("%s/" % self.PresubmitLocalPath())
     if len(dir_with_slash) == 1:
@@ skipping 79 matching lines @@
 
   def ReadFile(self, file_item, mode='r'):
     """Reads an arbitrary file.
 
     Deny reading anything outside the repository.
     """
     if isinstance(file_item, AffectedFile):
       file_item = file_item.AbsoluteLocalPath()
     if not file_item.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
-    return gclient_utils.FileRead(file_item, mode)
+    return gcl.ReadFile(file_item, mode)
 
   @staticmethod
   def _RightHandSideLinesImpl(affected_files):
     """Implements RightHandSideLines for InputApi and GclChange."""
     for af in affected_files:
       lines = af.NewContents()
       line_number = 0
       for line in lines:
         line_number += 1
         yield (af, line_number, line)
@@ skipping 57 matching lines @@
 
     The new version is the file in the user's workspace, i.e. the "right hand
     side".
 
     Contents will be empty if the file is a directory or does not exist.
     Note: The cariage returns (LF or CR) are stripped off.
     """
     if self.IsDirectory():
       return []
     else:
-      return gclient_utils.FileRead(self.AbsoluteLocalPath(),
-                                    'rU').splitlines()
+      return gcl.ReadFile(self.AbsoluteLocalPath()).splitlines()
 
   def OldContents(self):
     """Returns an iterator over the lines in the old version of file.
 
     The old version is the file in depot, i.e. the "left hand side".
     """
     raise NotImplementedError()  # Implement when needed
 
   def OldFileTempPath(self):
     """Returns the path on local disk where the old contents resides.
@@ skipping 11 matching lines @@
 class SvnAffectedFile(AffectedFile):
   """Representation of a file in a change out of a Subversion checkout."""
 
   def __init__(self, *args, **kwargs):
     AffectedFile.__init__(self, *args, **kwargs)
     self._server_path = None
     self._is_text_file = None
 
   def ServerPath(self):
     if self._server_path is None:
-      self._server_path = scm.SVN.CaptureInfo(
+      self._server_path = gclient_scm.CaptureSVNInfo(
           self.AbsoluteLocalPath()).get('URL', '')
     return self._server_path
 
   def IsDirectory(self):
     if self._is_directory is None:
       path = self.AbsoluteLocalPath()
       if os.path.exists(path):
         # Retrieve directly from the file system; it is much faster than
         # querying subversion, especially on Windows.
         self._is_directory = os.path.isdir(path)
       else:
-        self._is_directory = scm.SVN.CaptureInfo(
+        self._is_directory = gclient_scm.CaptureSVNInfo(
             path).get('Node Kind') in ('dir', 'directory')
     return self._is_directory
 
   def Property(self, property_name):
     if not property_name in self._properties:
-      self._properties[property_name] = scm.SVN.GetFileProperty(
+      self._properties[property_name] = gcl.GetSVNFileProperty(
           self.AbsoluteLocalPath(), property_name).rstrip()
     return self._properties[property_name]
 
   def IsTextFile(self):
     if self._is_text_file is None:
       if self.Action() == 'D':
         # A deleted file is not a text file.
         self._is_text_file = False
       elif self.IsDirectory():
         self._is_text_file = False
       else:
-        mime_type = scm.SVN.GetFileProperty(self.AbsoluteLocalPath(),
-                                            'svn:mime-type')
+        mime_type = gcl.GetSVNFileProperty(self.AbsoluteLocalPath(),
+                                           'svn:mime-type')
         self._is_text_file = (not mime_type or mime_type.startswith('text/'))
     return self._is_text_file
 
 
 class GitAffectedFile(AffectedFile):
   """Representation of a file in a change out of a git checkout."""
 
   def __init__(self, *args, **kwargs):
     AffectedFile.__init__(self, *args, **kwargs)
     self._server_path = None
@@ skipping 293 matching lines @@
   executer = GetTrySlavesExecuter()
   if default_presubmit:
     if verbose:
       output_stream.write("Running default presubmit script.\n")
     results += executer.ExecPresubmitScript(default_presubmit)
   for filename in presubmit_files:
     filename = os.path.abspath(filename)
     if verbose:
       output_stream.write("Running %s\n" % filename)
     # Accept CRLF presubmit script.
-    presubmit_script = gclient_utils.FileRead(filename, 'rU')
+    presubmit_script = gcl.ReadFile(filename, 'rU')
     results += executer.ExecPresubmitScript(presubmit_script)
 
   slaves = list(set(results))
   if slaves and verbose:
     output_stream.write(', '.join(slaves))
     output_stream.write('\n')
   return slaves
 
 
 class PresubmitExecuter(object):
@@ skipping 95 matching lines @@
   if default_presubmit:
     if verbose:
       output_stream.write("Running default presubmit script.\n")
     fake_path = os.path.join(change.RepositoryRoot(), 'PRESUBMIT.py')
     results += executer.ExecPresubmitScript(default_presubmit, fake_path)
   for filename in presubmit_files:
     filename = os.path.abspath(filename)
     if verbose:
       output_stream.write("Running %s\n" % filename)
     # Accept CRLF presubmit script.
-    presubmit_script = gclient_utils.FileRead(filename, 'rU')
+    presubmit_script = gcl.ReadFile(filename, 'rU')
     results += executer.ExecPresubmitScript(presubmit_script, filename)
 
   errors = []
   notifications = []
   warnings = []
   for result in results:
     if not result.IsFatal() and not result.ShouldPrompt():
       notifications.append(result)
     elif result.ShouldPrompt():
       warnings.append(result)
@@ skipping 76 matching lines @@
   options, args = parser.parse_args(argv[1:])
   if not options.root:
     options.root = os.getcwd()
   if os.path.isdir(os.path.join(options.root, '.git')):
     change_class = GitChange
     if not options.files:
       if args:
         options.files = ParseFiles(args, options.recursive)
       else:
         # Grab modified files.
-        options.files = scm.GIT.CaptureStatus([options.root])
+        options.files = gclient_scm.CaptureGitStatus([options.root])
   elif os.path.isdir(os.path.join(options.root, '.svn')):
     change_class = SvnChange
     if not options.files:
       if args:
         options.files = ParseFiles(args, options.recursive)
       else:
         # Grab modified files.
-        options.files = scm.SVN.CaptureStatus([options.root])
+        options.files = gclient_scm.CaptureSVNStatus([options.root])
   else:
     # Doesn't seem under source control.
     change_class = Change
   if options.verbose:
     if len(options.files) != 1:
       print "Found %d files." % len(options.files)
     else:
       print "Found 1 file."
   return not DoPresubmitChecks(change_class(options.name,
                                             options.description,
                                             options.root,
                                             options.files,
                                             options.issue,
                                             options.patchset),
                                options.commit,
                                options.verbose,
                                sys.stdout,
                                sys.stdin,
                                options.default_presubmit,
                                options.may_prompt)
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))