Some preparation work towards the gclient.py refactor.

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,
@@ skipping 24 matching lines @@
     self.retcode = retcode
     self.stdout = stdout
     self.stderr = stderr
 
 
 def CheckCall(command, cwd=None, print_error=True):
   """Like subprocess.check_call() but returns stdout.
 
   Works on python 2.4
   """
-  logging.debug("%s, cwd=%s" % (str(command), str(cwd)))
+  logging.debug('%s, cwd=%s' % (str(command), str(cwd)))
   try:
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
     process = subprocess.Popen(command, cwd=cwd,
                                shell=sys.platform.startswith('win'),
                                stdout=subprocess.PIPE,
                                stderr=stderr)
     std_out, std_err = process.communicate()
   except OSError, e:
     raise CheckCallError(command, cwd, e.errno, None)
   if process.returncode:
     raise CheckCallError(command, cwd, process.returncode, std_out, std_err)
   return std_out, std_err
 
 
 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\./]+)(?:@(.+))?"
+    regex = r'(ssh://(?:[\w]+@)?[-\w:\.]+/[-\w\./]+)(?:@(.+))?'
     components = re.search(regex, url).groups()
   else:
-    components = url.split("@")
+    components = url.split('@', 1)
     if len(components) == 1:
       components += [None]
   return tuple(components)
 
 
 def ParseXML(output):
   try:
     return xml.dom.minidom.parseString(output)
   except xml.parsers.expat.ExpatError:
     return None
@@ skipping 73 matching lines @@
   Doing so would be hazardous, as it's not a directory slated for removal.
   In the ordinary case, this is not a problem: for our purposes, the user
   will never lack write permission on *path's parent.
   """
   logging.debug(path)
   file_path = os.path.join(*path)
   if not os.path.exists(file_path):
     return
 
   if os.path.islink(file_path) or not os.path.isdir(file_path):
-    raise Error("RemoveDirectory asked to remove non-directory %s" % file_path)
+    raise Error('RemoveDirectory asked to remove non-directory %s' % file_path)
 
   has_win32api = False
   if sys.platform == 'win32':
     has_win32api = True
     # Some people don't have the APIs installed. In that case we'll do without.
     try:
       win32api = __import__('win32api')
       win32con = __import__('win32con')
     except ImportError:
       has_win32api = False
@@ skipping 70 matching lines @@
   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.
   """
   logging.debug(command)
   if print_messages:
-    print("\n________ running \'%s\' in \'%s\'"
+    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,
       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 = ""
+  in_line = ''
   while in_byte:
-    if in_byte != "\r":
+    if in_byte != '\r':
       if print_stdout:
         if not print_messages:
-          print("\n________ running \'%s\' in \'%s\'"
+          print('\n________ running \'%s\' in \'%s\''
               % (' '.join(command), in_directory))
           print_messages = True
         sys.stdout.write(in_byte)
-      if in_byte != "\n":
+      if in_byte != '\n':
         in_line += in_byte
-    if in_byte == "\n" and filter_fn:
+    if in_byte == '\n' and filter_fn:
       filter_fn(in_line)
-      in_line = ""
+      in_line = ''
     in_byte = kid.stdout.read(1)
   rv = kid.wait()
 
   if rv:
-    msg = "failed to run command: %s" % " ".join(command)
+    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.
@@ skipping 41 matching lines @@
       return None
     path = new_path
 
 
 def GetGClientRootAndEntries(path=None):
   """Returns the gclient root and the dict of entries."""
   config_file = '.gclient_entries'
   config_path = FindFileUpwards(config_file, path)
 
   if not config_path:
-    print "Can't find", config_file
+    print 'Can\'t find', config_file

[bradn, 2010/06/11 17:17:52]

Technically the style guide /gpylint allows alternate quotes, in the case where
it reduces the escaping in the string.

     return None
 
   env = {}
   execfile(config_path, env)
   config_dir = os.path.dirname(config_path)
   return config_dir, env['entries']