Group SCM-specific functions in classes to simplify generalization of the interface.

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Generic utils."""
+
 import errno
 import os
 import re
 import stat
 import subprocess
 import sys
 import time
 import xml.dom.minidom
 import xml.parsers.expat
 
-## Generic utils
-
 
 def SplitUrlRevision(url):
   """Splits url and returns a two-tuple: url, rev"""
   if url.startswith('ssh:'):
     # Make sure ssh://test@example.com/test.git@stable works
     regex = r"(ssh://(?:[\w]+@)?[-\w:\.]+/[-\w\.]+)(?:@([\w/]+))?"
     components = re.search(regex, url).groups()
   else:
     components = url.split("@")
     if len(components) == 1:
@@ skipping 32 matching lines @@
 class PrintableObject(object):
   def __str__(self):
     output = ''
     for i in dir(self):
       if i.startswith('__'):
         continue
       output += '%s = %s\n' % (i, str(getattr(self, i, '')))
     return output
 
 
-def FileRead(filename):
+def FileRead(filename, mode='rU'):
   content = None
-  f = open(filename, "rU")
+  f = open(filename, mode)
   try:
     content = f.read()
   finally:
     f.close()
   return content
 
 
-def FileWrite(filename, content):
-  f = open(filename, "w")
+def FileWrite(filename, content, mode='w'):
+  f = open(filename, mode)
   try:
     f.write(content)
   finally:
     f.close()
 
 
 def RemoveDirectory(*path):
   """Recursively removes a directory, even if it's marked read-only.
 
   Remove the directory located at *path, if it exists.
@@ skipping 93 matching lines @@
                             print_messages,
                             print_stdout,
                             fail_status=None, filter=None):
   """Runs command, a list, in directory in_directory.
 
   If print_messages is true, a message indicating what is being done
   is printed to stdout. If print_messages is false, the message is printed
   only if we actually need to print something else as well, so you can
   get the context of the output. If print_messages is false and print_stdout
   is false, no output at all is generated.
-  
-  Also, if print_stdout is true, the command's stdout is also forwarded 
-  to stdout. 
+
+  Also, if print_stdout is true, the command's stdout is also forwarded
+  to stdout.
 
   If a filter function is specified, it is expected to take a single
   string argument, and it will be called with each line of the
   subprocess's output. Each line has had the trailing newline character
   trimmed.
 
   If the command fails, as indicated by a nonzero exit status, gclient will
   exit with an exit status of fail_status.  If fail_status is None (the
   default), gclient will raise an Error exception.
   """
 
   if print_messages:
     print("\n________ running \'%s\' in \'%s\'"
           % (' '.join(command), in_directory))
 
   # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for the
   # executable, but shell=True makes subprocess on Linux fail when it's called
   # with a list because it only tries to execute the first item in the list.
   kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
-      shell=(sys.platform == 'win32'), stdout=subprocess.PIPE, 
+      shell=(sys.platform == 'win32'), stdout=subprocess.PIPE,
       stderr=subprocess.STDOUT)
 
   # Also, we need to forward stdout to prevent weird re-ordering of output.
   # This has to be done on a per byte basis to make sure it is not buffered:
   # normally buffering is done for each line, but if svn requests input, no
   # end-of-line character is output after the prompt and it would not show up.
   in_byte = kid.stdout.read(1)
   in_line = ""
   while in_byte:
     if in_byte != "\r":
       if print_stdout:
         if not print_messages:
           print("\n________ running \'%s\' in \'%s\'"
               % (' '.join(command), in_directory))
-          print_messages = True 
+          print_messages = True
         sys.stdout.write(in_byte)
       if in_byte != "\n":
         in_line += in_byte
     if in_byte == "\n" and filter:
       filter(in_line)
       in_line = ""
     in_byte = kid.stdout.read(1)
   rv = kid.wait()
 
   if rv:
     msg = "failed to run command: %s" % " ".join(command)
 
     if fail_status != None:
       print >>sys.stderr, msg
       sys.exit(fail_status)
 
     raise Error(msg)
 
 
 def IsUsingGit(root, paths):
   """Returns True if we're using git to manage any of our checkouts.
   |entries| is a list of paths to check."""
   for path in paths:
     if os.path.exists(os.path.join(root, path, '.git')):
       return True
   return False