Convert all print statements to use options.stdout.

gclient_scm.py

 # Copyright (c) 2010 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
 import subprocess
 import sys
 import time
 
 import scm
 import gclient_utils
 
 
 class DiffFilterer(object):
   """Simple class which tracks which file is being diffed and
   replaces instances of its file name in the original and
   working copy lines of the svn/git diff output."""
   index_string = "Index: "
   original_prefix = "--- "
   working_prefix = "+++ "
 
-  def __init__(self, relpath):
+  def __init__(self, relpath, stdout):

[bradn, 2010/09/01 20:15:54]

Did you want this to have  a default of sys.stdout ?

[M-A Ruel, 2010/09/01 23:45:35]

No.

     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._relpath = relpath.replace("\\", "/")
     self._current_file = ""
     self._replacement_file = ""
+    self._stdout = stdout
 
   def SetCurrentFile(self, current_file):
     self._current_file = current_file
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._replacement_file = posixpath.join(self._relpath, current_file)
 
-  def ReplaceAndPrint(self, line):
-    print(line.replace(self._current_file, self._replacement_file))
+  def _Replace(self, line):
+    return line.replace(self._current_file, self._replacement_file)
 
   def Filter(self, line):
     if (line.startswith(self.index_string)):
       self.SetCurrentFile(line[len(self.index_string):])
-      self.ReplaceAndPrint(line)
+      line = self._Replace(line)
     else:
       if (line.startswith(self.original_prefix) or
           line.startswith(self.working_prefix)):
-        self.ReplaceAndPrint(line)
-      else:
-        print line
+        line = self._Replace(line)
+    self._stdout.write(line + '\n')
 
 
 ### SCM abstraction layer
 
 # Factory Method for SCM wrapper creation
 
 def GetScmName(url):
   if url:
     url, _ = gclient_utils.SplitUrlRevision(url)
     if (url.startswith('git://') or url.startswith('ssh://') or
@@ skipping 95 matching lines @@
         command, cwd=path, filter_fn=filterer.Filter, stdout=options.stdout)
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
-
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     self._CheckMinVersion("1.6.6")
 
     default_rev = "refs/heads/master"
     url, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     rev_str = ""
     revision = deps_revision
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if not revision:
       revision = default_rev
 
     rev_str = ' at %s' % revision
     files = []
 
     printed_path = False
     verbose = []
     if options.verbose:
-      print("\n_____ %s%s" % (self.relpath, rev_str))
+      options.stdout.write("\n_____ %s%s\n" % (self.relpath, rev_str))
       verbose = ['--verbose']
       printed_path = True
 
     if revision.startswith('refs/heads/'):
       rev_type = "branch"
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     if not os.path.exists(self.checkout_path):
-      self._Clone(revision, url, options.verbose)
+      self._Clone(revision, url, options)
       files = self._Run(['ls-files']).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
-        print ""
+        options.stdout.write('\n')
       return
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
@@ skipping 39 matching lines @@
       try:
         remote_output, remote_err = scm.GIT.Capture(
             ['remote'] + verbose + ['update'],
             self.checkout_path,
             print_error=False)
         break
       except gclient_utils.CheckCallError, e:
         # Hackish but at that point, git is known to work so just checking for
         # 502 in stderr should be fine.
         if '502' in e.stderr:
-          print str(e)
-          print "Sleeping 15 seconds and retrying..."
+          options.stdout.write(str(e) + '\n')
+          options.stdout.write('Sleeping 15 seconds and retrying...\n')
           time.sleep(15)
           continue
         raise
 
     if verbose:
-      print remote_output.strip()
+      options.stdout.write(remote_output.strip() + '\n')
       # git remote update prints to stderr when used with --verbose
-      print remote_err.strip()
+      options.stdout.write(remote_err.strip() + '\n')
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       self._Run(['reset', '--hard', 'HEAD'], redirect_stdout=False)
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
-      self._CheckDetachedHead(rev_str)
+      self._CheckDetachedHead(rev_str, options)
       self._Run(['checkout', '--quiet', '%s^0' % revision])
       if not printed_path:
-        print("\n_____ %s%s" % (self.relpath, rev_str))
+        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
     elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
-        self._AttemptRebase(upstream_branch, files, verbose=options.verbose,
+        self._AttemptRebase(upstream_branch, files, options,
                             newbase=revision, printed_path=printed_path)
         printed_path = True
       else:
         # Can't find a merge-base since we don't know our upstream. That makes
         # this command VERY likely to produce a rebase failure. For now we
         # assume origin is our upstream since that's what the old behavior was.
         upstream_branch = 'origin'
         if options.revision or deps_revision:
           upstream_branch = revision
-        self._AttemptRebase(upstream_branch, files=files,
-                            verbose=options.verbose, printed_path=printed_path)
+        self._AttemptRebase(upstream_branch, files, options,
+                            printed_path=printed_path)
         printed_path = True
     elif rev_type == 'hash':
       # case 2
-      self._AttemptRebase(upstream_branch, files, verbose=options.verbose,
+      self._AttemptRebase(upstream_branch, files, options,
                           newbase=revision, printed_path=printed_path)
       printed_path = True
     elif revision.replace('heads', 'remotes/origin') != upstream_branch:
       # case 4
       new_base = revision.replace('heads', 'remotes/origin')
       if not printed_path:
-        print("\n_____ %s%s" % (self.relpath, rev_str))
+        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
                      "OR git checkout -b <some new branch> %s" % new_base)
       raise gclient_utils.Error(switch_error)
     else:
       # case 3 - the default case
       files = self._Run(['diff', upstream_branch, '--name-only']).split()
       if verbose:
-        print "Trying fast-forward merge to branch : %s" % upstream_branch
+        options.stdout.write('Trying fast-forward merge to branch : %s\n' %
+            upstream_branch)
       try:
         merge_output, merge_err = scm.GIT.Capture(['merge', '--ff-only',
                                                    upstream_branch],
                                                   self.checkout_path,
                                                   print_error=False)
       except gclient_utils.CheckCallError, e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           if not printed_path:
-            print("\n_____ %s%s" % (self.relpath, rev_str))
+            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
             printed_path = True
           while True:
             try:
+              # TODO(maruel): That can't work.
               action = str(raw_input("Cannot fast-forward merge, attempt to "
                                      "rebase? (y)es / (q)uit / (s)kip : "))
             except ValueError:
               gclient_utils.Error('Invalid Character')
               continue
             if re.match(r'yes|y', action, re.I):
-              self._AttemptRebase(upstream_branch, files,
-                                  verbose=options.verbose,
+              self._AttemptRebase(upstream_branch, files, options,
                                   printed_path=printed_path)
               printed_path = True
               break
             elif re.match(r'quit|q', action, re.I):
               raise gclient_utils.Error("Can't fast-forward, please merge or "
                                         "rebase manually.\n"
                                         "cd %s && git " % self.checkout_path
                                         + "rebase %s" % upstream_branch)
             elif re.match(r'skip|s', action, re.I):
-              print "Skipping %s" % self.relpath
+              options.stdout.write('Skipping %s\n' % self.relpath)
               return
             else:
-              print "Input not recognized"
+              options.stdout.write('Input not recognized\n')
         elif re.match("error: Your local changes to '.*' would be "
                       "overwritten by merge.  Aborting.\nPlease, commit your "
                       "changes or stash them before you can merge.\n",
                       e.stderr):
           if not printed_path:
-            print("\n_____ %s%s" % (self.relpath, rev_str))
+            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
             printed_path = True
           raise gclient_utils.Error(e.stderr)
         else:
           # Some other problem happened with the merge
           logging.error("Error during fast-forward merge in %s!" % self.relpath)
-          print e.stderr
+          options.stdout.write(e.stderr + '\n')
           raise
       else:
         # Fast-forward merge was successful
         if not re.match('Already up-to-date.', merge_output) or verbose:
           if not printed_path:
-            print("\n_____ %s%s" % (self.relpath, rev_str))
+            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
             printed_path = True
           print merge_output.strip()
           if merge_err:
-            print "Merge produced error output:\n%s" % merge_err.strip()
+            options.stdout.write('Merge produced error output:\n%s\n' %
+                merge_err.strip())
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
-            print ""
+            options.stdout.write('\n')
 
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
     # If the rebase generated a conflict, abort and ask user to fix
     if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\nConflict while rebasing this branch.\n'
                                 'Fix the conflict and run gclient again.\n'
                                 'See man git-rebase for details.\n'
                                 % (self.relpath, rev_str))
 
     if verbose:
-      print "Checked out revision %s" % self.revinfo(options, (), None)
+      options.stdout.write('Checked out revision %s\n' %
+          self.revinfo(options, (), None))
 
   def revert(self, options, args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      print("\n_____ %s is missing, synching instead" % self.relpath)
+      options.stdout.write('\n_____ %s is missing, synching instead\n' %
+          self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', 'origin/')
 
     files = self._Run(['diff', deps_revision, '--name-only']).split()
     self._Run(['reset', '--hard', deps_revision], redirect_stdout=False)
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def revinfo(self, options, args, file_list):
     """Display revision"""
     return self._Run(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
-      print('\n________ couldn\'t run status in %s:\nThe directory '
-            'does not exist.' % self.checkout_path)
+      options.stdout.write(
+          ('\n________ couldn\'t run status in %s:\nThe directory '
+           'does not exist.\n') % self.checkout_path)
     else:
       merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
       self._Run(['diff', '--name-status', merge_base], redirect_stdout=False)
       files = self._Run(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
     # Strip from last '/'
     # Equivalent to unix basename
     base_url = self.url
     return base_url[:base_url.rfind('/')] + url
 
-  def _Clone(self, revision, url, verbose=False):
+  def _Clone(self, revision, url, options):
     """Clone a git repository from the given URL.
 
     Once we've cloned the repo, we checkout a working branch if the specified
     revision is a branch head. If it is a tag or a specific commit, then we
     leave HEAD detached as it makes future updates simpler -- in this case the
     user should first create a new branch or switch to an existing branch before
     making changes in the repo."""
-    if not verbose:
+    if not options.verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
-      print ""
+      options.stdout.write('\n')
 
     clone_cmd = ['clone']
     if revision.startswith('refs/heads/'):
       clone_cmd.extend(['-b', revision.replace('refs/heads/', '')])
       detach_head = False
     else:
       clone_cmd.append('--no-checkout')
       detach_head = True
-    if verbose:
+    if options.verbose:
       clone_cmd.append('--verbose')
     clone_cmd.extend([url, self.checkout_path])
 
     for _ in range(3):
       try:
         self._Run(clone_cmd, cwd=self._root_dir, redirect_stdout=False)
         break
       except gclient_utils.Error, e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
         # CheckCall().
         # Too bad we don't have access to the actual output.
         # We should check for "transfer closed with NNN bytes remaining to
         # read". In the meantime, just make sure .git exists.
         if (e.args[0] == 'git command clone returned 128' and
             os.path.exists(os.path.join(self.checkout_path, '.git'))):
-          print str(e)
-          print "Retrying..."
+          options.stdout.write(str(e) + '\n')
+          options.stdout.write('Retrying...\n')
           continue
         raise e
 
     if detach_head:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Run(['checkout', '--quiet', '%s^0' % revision])
-      print \
-        "Checked out %s to a detached HEAD. Before making any commits\n" \
-        "in this repo, you should use 'git checkout <branch>' to switch to\n" \
-        "an existing branch or use 'git checkout origin -b <branch>' to\n" \
-        "create a new branch for your work." % revision
+      options.stdout.write(
+        ('Checked out %s to a detached HEAD. Before making any commits\n'
+         'in this repo, you should use \'git checkout <branch>\' to switch to\n'
+         'an existing branch or use \'git checkout origin -b <branch>\' to\n'
+         'create a new branch for your work.') % revision)
 
-  def _AttemptRebase(self, upstream, files, verbose=False, newbase=None,
+  def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     files.extend(self._Run(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
-      print "\n_____ %s : Attempting rebase onto %s..." % (self.relpath,
-                                                           revision)
+      options.stdout.write('\n_____ %s : Attempting rebase onto %s...\n' % (
+          self.relpath, revision))
       printed_path = True
     else:
-      print "Attempting rebase onto %s..." % revision
+      options.stdout.write('Attempting rebase onto %s...\n' % revision)
 
     # Build the rebase command here using the args
     # git rebase [options] [--onto <newbase>] <upstream> [<branch>]
     rebase_cmd = ['rebase']
-    if verbose:
+    if options.verbose:
       rebase_cmd.append('--verbose')
     if newbase:
       rebase_cmd.extend(['--onto', newbase])
     rebase_cmd.append(upstream)
     if branch:
       rebase_cmd.append(branch)
 
     try:
       rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
                                                   self.checkout_path,
@@ skipping 12 matching lines @@
             self._Run(['reset', '--hard', 'HEAD'], redirect_stdout=False)
             # Should this be recursive?
             rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
                                                         self.checkout_path)
             break
           elif re.match(r'quit|q', rebase_action, re.I):
             raise gclient_utils.Error("Please merge or rebase manually\n"
                                       "cd %s && git " % self.checkout_path
                                       + "%s" % ' '.join(rebase_cmd))
           elif re.match(r'show|s', rebase_action, re.I):
-            print "\n%s" % e.stderr.strip()
+            options.stdout.write('\n%s\n' % e.stderr.strip())
             continue
           else:
             gclient_utils.Error("Input not recognized")
             continue
       elif re.search(r'^CONFLICT', e.stdout, re.M):
         raise gclient_utils.Error("Conflict while rebasing this branch.\n"
                                   "Fix the conflict and run gclient again.\n"
                                   "See 'man git-rebase' for details.\n")
       else:
-        print e.stdout.strip()
-        print "Rebase produced error output:\n%s" % e.stderr.strip()
+        options.stdout.write(e.stdout.strip() + '\n')
+        options.stdout.write('Rebase produced error output:\n%s\n' %
+            e.stderr.strip())
         raise gclient_utils.Error("Unrecognized error, please merge or rebase "
                                   "manually.\ncd %s && git " %
                                   self.checkout_path
                                   + "%s" % ' '.join(rebase_cmd))
 
     print rebase_output.strip()
     if rebase_err:
-      print "Rebase produced error output:\n%s" % rebase_err.strip()
-    if not verbose:
+      options.stdout.write('Rebase produced error output:\n%s\n' %
+          rebase_err.strip())
+    if not options.verbose:
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
-      print ""
+      options.stdout.write('\n')
 
   @staticmethod
   def _CheckMinVersion(min_version):
     (ok, current_version) = scm.GIT.AssertVersion(min_version)
     if not ok:
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
@@ skipping 17 matching lines @@
     try:
       scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
                        '--ignore-submodules', 'HEAD', '--'], self.checkout_path,
                        print_error=False)
     except gclient_utils.CheckCallError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYour index contains uncommitted changes\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
 
-  def _CheckDetachedHead(self, rev_str):
+  def _CheckDetachedHead(self, rev_str, options):
     # HEAD is detached. Make sure it is safe to move away from (i.e., it is
     # reference by a commit). If not, error out -- most likely a rebase is
     # in progress, try to detect so we can give a better error.
     try:
       _, _ = scm.GIT.Capture(
         ['name-rev', '--no-undefined', 'HEAD'],
         self.checkout_path,
         print_error=False)
     except gclient_utils.CheckCallError:
       # Commit is not contained by any rev. See if the user is rebasing:
       if self._IsRebasing():
         # Punt to the user
         raise gclient_utils.Error('\n____ %s%s\n'
                                   '\tAlready in a conflict, i.e. (no branch).\n'
                                   '\tFix the conflict and run gclient again.\n'
                                   '\tOr to abort run:\n\t\tgit-rebase --abort\n'
                                   '\tSee man git-rebase for details.\n'
                                    % (self.relpath, rev_str))
       # Let's just save off the commit so we can proceed.
       name = "saved-by-gclient-" + self._Run(["rev-parse", "--short", "HEAD"])
       self._Run(["branch", name])
-      print ("\n_____ found an unreferenced commit and saved it as '%s'" % name)
+      options.stdout.write(
+          '\n_____ found an unreferenced commit and saved it as \'%s\'\n' %
+          name)
 
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Run(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
   def _Run(self, args, cwd=None, redirect_stdout=True):
     # TODO(maruel): Merge with Capture or better gclient_utils.CheckCall().
@@ skipping 46 matching lines @@
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       raise gclient_utils.Error('Directory %s is not present.' % path)
     command = ['svn', 'diff', '-x', '--ignore-eol-style']
     command.extend(args)
 
-    filterer = DiffFilterer(self.relpath)
+    filterer = DiffFilterer(self.relpath, options.stdout)
     gclient_utils.CheckCallAndFilter(command, cwd=path, always=False,
         print_stdout=False, filter_fn=filterer.Filter,
         stdout=options.stdout)
 
   def update(self, options, args, file_list):
     """Runs svn to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     # Only update if git is not controlling the directory.
     checkout_path = os.path.join(self._root_dir, self.relpath)
     git_path = os.path.join(self._root_dir, self.relpath, '.git')
     if os.path.exists(git_path):
-      print("________ found .git directory; skipping %s" % self.relpath)
+      options.stdout.write('________ found .git directory; skipping %s\n' %
+          self.relpath)
       return
 
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     # revision is the revision to match. It is None if no revision is specified,
     # i.e. the 'deps ain't pinned'.
     url, revision = gclient_utils.SplitUrlRevision(self.url)
     # Keep the original unpinned url for reference in case the repo is switched.
     base_url = url
@@ skipping 39 matching lines @@
     if from_info['URL'] != base_url:
       # The repository url changed, need to switch.
       to_info = scm.SVN.CaptureInfo(url, '.')
       if not to_info.get('Repository Root') or not to_info.get('UUID'):
         # The url is invalid or the server is not accessible, it's safer to bail
         # out right now.
         raise gclient_utils.Error('This url is unreachable: %s' % url)
       can_switch = ((from_info['Repository Root'] != to_info['Repository Root'])
                     and (from_info['UUID'] == to_info['UUID']))
       if can_switch:
-        print('\n_____ relocating %s to a new checkout' % self.relpath)
+        options.stdout.write('\n_____ relocating %s to a new checkout\n' %
+            self.relpath)
         # We have different roots, so check if we can switch --relocate.
         # Subversion only permits this if the repository UUIDs match.
         # Perform the switch --relocate, then rewrite the from_url
         # to reflect where we "are now."  (This is the same way that
         # Subversion itself handles the metadata when switch --relocate
         # is used.)  This makes the checks below for whether we
         # can update to a revision or have to switch to a different
         # branch work as expected.
         # TODO(maruel):  TEST ME !
         command = ['switch', '--relocate',
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
         self._Run(command, options, cwd=self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
       else:
         if not options.force and not options.reset:
           # Look for local modifications but ignore unversioned files.
           for status in scm.SVN.CaptureStatus(checkout_path):
             if status[0] != '?':
               raise gclient_utils.Error(
                   ('Can\'t switch the checkout to %s; UUID don\'t match and '
                    'there is local changes in %s. Delete the directory and '
                    'try again.') % (url, checkout_path))
         # Ok delete it.
-        print('\n_____ switching %s to a new checkout' % self.relpath)
+        options.stdout.write('\n_____ switching %s to a new checkout\n' %
+            self.relpath)
         gclient_utils.RemoveDirectory(checkout_path)
         # We need to checkout.
         command = ['checkout', url, checkout_path]
         command = self._AddAdditionalUpdateFlags(command, options, revision)
         self._RunAndGetFileList(command, options, file_list, self._root_dir)
         return
 
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and str(from_info['Revision']) == revision:
       if options.verbose or not forced_revision:
-        print('\n_____ %s%s' % (self.relpath, rev_str))
+        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
       return
 
     command = ['update', checkout_path]
     command = self._AddAdditionalUpdateFlags(command, options, revision)
     self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
   def updatesingle(self, options, args, file_list):
     checkout_path = os.path.join(self._root_dir, self.relpath)
     filename = args.pop()
     if scm.SVN.AssertVersion("1.5")[0]:
@@ skipping 25 matching lines @@
   def revert(self, options, args, file_list):
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      print("\n_____ %s is missing, synching instead" % self.relpath)
+      options.stdout.write('\n_____ %s is missing, synching instead\n' %
+          self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     # Do a flush of sys.stdout every 10 secs or so otherwise it may never be
     # flushed fast enough for buildbot.
     last_flushed_at = time.time()
     sys.stdout.flush()
 
     for file_status in scm.SVN.CaptureStatus(path):
       file_path = os.path.join(path, file_status[1])
       if file_status[0][0] == 'X':
         # Ignore externals.
         logging.info('Ignoring external %s' % file_path)
         continue
 
       if logging.getLogger().isEnabledFor(logging.INFO):
         logging.info('%s%s' % (file[0], file[1]))
       else:
-        print(file_path)
+        options.stdout.write(file_path + '\n')
         # Flush at least 10 seconds between line writes.  We wait at least 10
         # seconds to avoid overloading the reader that called us with output,
         # which can slow busy readers down.
         if (time.time() - last_flushed_at) > 10:
           last_flushed_at = time.time()
           sys.stdout.flush()
 
       if file_status[0].isspace():
         logging.error('No idea what is the status of %s.\n'
                       'You just found a bug in gclient, please ping '
@@ skipping 31 matching lines @@
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     path = os.path.join(self._root_dir, self.relpath)
     command = ['status'] + args
     if not os.path.isdir(path):
       # svn status won't work if the directory doesn't exist.
-      print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
-            "does not exist."
-            % (' '.join(command), path))
+      options.stdout.write(
+          ('\n________ couldn\'t run \'%s\' in \'%s\':\nThe directory '
+           'does not exist.') % (' '.join(command), path))
       # There's no file list to retrieve.
     else:
       self._RunAndGetFileList(command, options, file_list)
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
 
   def _Run(self, args, options, **kwargs):
     """Runs a commands that goes to stdout."""
@@ skipping 14 matching lines @@
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if ((options.force or options.manually_grab_svn_rev) and
         scm.SVN.AssertVersion("1.5")[0]):
       new_command.append('--force')
     return new_command