gclient: use the print function

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Meta checkout manager supporting both Subversion and GIT."""
 # Files
 #   .gclient      : Current client configuration, written by 'config' command.
 #                   Format is a Python script defining 'solutions', a list whose
 #                   entries each are maps binding the strings "name" and "url"
@@ skipping 58 matching lines @@
 #   Example:
 #     target_os = [ "android" ]
 #
 #   If the "target_os_only" key is also present and true, then *only* the
 #   operating systems listed in "target_os" will be used.
 #
 #   Example:
 #     target_os = [ "ios" ]
 #     target_os_only = True
 
+from __future__ import print_function
+
 __version__ = '0.7'
 
 import ast
 import copy
 import json
 import logging
 import optparse
 import os
 import platform
 import posixpath
@@ skipping 148 matching lines @@
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
     self._custom_deps = custom_deps or {}
     self._custom_hooks = custom_hooks or []
 
     # TODO(iannucci): Remove this when all masters are correctly substituting
     # the new blink url.
     if (self._custom_vars.get('webkit_trunk', '') ==
         'svn://svn-mirror.golo.chromium.org/webkit-readonly/trunk'):
       new_url = 'svn://svn-mirror.golo.chromium.org/blink/trunk'
-      print 'Overwriting Var("webkit_trunk") with %s' % new_url
+      print('Overwriting Var("webkit_trunk") with %s' % new_url)
       self._custom_vars['webkit_trunk'] = new_url
 
     # Post process the url to remove trailing slashes.
     if isinstance(self._url, basestring):
       # urls are sometime incorrectly written as proto://host/path/@rev. Replace
       # it to proto://host/path@rev.
       self._url = self._url.replace('/@', '@')
     elif not isinstance(self._url,
         (self.FromImpl, self.FileImpl, None.__class__)):
       raise gclient_utils.Error(
@@ skipping 619 matching lines @@
               """Git-specific path marshaling. It is optimized for git-grep."""
 
               def mod_path(git_pathspec):
                 match = re.match('^(\\S+?:)?([^\0]+)$', git_pathspec)
                 modified_path = os.path.join(self.name, match.group(2))
                 branch = match.group(1) or ''
                 return '%s%s' % (branch, modified_path)
 
               match = re.match('^Binary file ([^\0]+) matches$', line)
               if match:
-                print 'Binary file %s matches\n' % mod_path(match.group(1))
+                print('Binary file %s matches\n' % mod_path(match.group(1)))
                 return
 
               items = line.split('\0')
               if len(items) == 2 and items[1]:
-                print '%s : %s' % (mod_path(items[0]), items[1])
+                print('%s : %s' % (mod_path(items[0]), items[1]))
               elif len(items) >= 2:
                 # Multiple null bytes or a single trailing null byte indicate
                 # git is likely displaying filenames only (such as with -l)
-                print '\n'.join(mod_path(path) for path in items if path)
+                print('\n'.join(mod_path(path) for path in items if path))
               else:
-                print line
+                print(line)
           else:
             print_stdout = True
             filter_fn = None
 
           if parsed_url is None:
-            print >> sys.stderr, 'Skipped omitted dependency %s' % cwd
+            print('Skipped omitted dependency %s' % cwd, file=sys.stderr)
           elif os.path.isdir(cwd):
             try:
               gclient_utils.CheckCallAndFilter(
                   args, cwd=cwd, env=env, print_stdout=print_stdout,
                   filter_fn=filter_fn,
                   )
             except subprocess2.CalledProcessError:
               if not options.ignore:
                 raise
           else:
-            print >> sys.stderr, 'Skipped missing %s' % cwd
+            print('Skipped missing %s' % cwd, file=sys.stderr)
 
 
   @gclient_utils.lockedmethod
   def _run_is_done(self, file_list, parsed_url):
     # Both these are kept for hooks that are run as a separate tree traversal.
     self._file_list = file_list
     self._parsed_url = parsed_url
     self._processed = True
 
   @staticmethod
@@ skipping 52 matching lines @@
     self._hooks_ran = True
     for hook in self.GetHooks(options):
       try:
         start_time = time.time()
         gclient_utils.CheckCallAndFilterAndHeader(
             hook, cwd=self.root.root_dir, always=True)
       except (gclient_utils.Error, subprocess2.CalledProcessError), e:
         # Use a discrete exit status code of 2 to indicate that a hook action
         # failed.  Users of this script may wish to treat hook action failures
         # differently from VC failures.
-        print >> sys.stderr, 'Error: %s' % str(e)
+        print('Error: %s' % str(e), file=sys.stderr)
         sys.exit(2)
       finally:
         elapsed_time = time.time() - start_time
         if elapsed_time > 10:
-          print "Hook '%s' took %.2f secs" % (
-              gclient_utils.CommandToStr(hook), elapsed_time)
+          print("Hook '%s' took %.2f secs" % (
+              gclient_utils.CommandToStr(hook), elapsed_time))
 
   def RunPreDepsHooks(self):
     assert self.processed
     assert self.deps_parsed
     assert not self.pre_deps_hooks_ran
     assert not self.hooks_ran
     for s in self.dependencies:
       assert not s.processed
     self._pre_deps_hooks_ran = True
     for hook in self.pre_deps_hooks:
       try:
         start_time = time.time()
         gclient_utils.CheckCallAndFilterAndHeader(
             hook, cwd=self.root.root_dir, always=True)
       except (gclient_utils.Error, subprocess2.CalledProcessError), e:
         # Use a discrete exit status code of 2 to indicate that a hook action
         # failed.  Users of this script may wish to treat hook action failures
         # differently from VC failures.
-        print >> sys.stderr, 'Error: %s' % str(e)
+        print('Error: %s' % str(e), file=sys.stderr)
         sys.exit(2)
       finally:
         elapsed_time = time.time() - start_time
         if elapsed_time > 10:
-          print "Hook '%s' took %.2f secs" % (
-              gclient_utils.CommandToStr(hook), elapsed_time)
+          print("Hook '%s' took %.2f secs" % (
+              gclient_utils.CommandToStr(hook), elapsed_time))
 
 
   def subtree(self, include_all):
     """Breadth first recursion excluding root node."""
     dependencies = self.dependencies
     for d in dependencies:
       if d.should_process or include_all:
         yield d
     for d in dependencies:
       for i in d.subtree(include_all):
@@ skipping 352 matching lines @@
       if not path:
         return None
       client = GClient(path, options)
       client.SetConfig(gclient_utils.FileRead(
           os.path.join(path, options.config_filename)))
       client = client.MigrateConfigToGit(path, options)
 
     if (options.revisions and
         len(client.dependencies) > 1 and
         any('@' not in r for r in options.revisions)):
-      print >> sys.stderr, (
-          'You must specify the full solution name like --revision %s@%s\n'
-          'when you have multiple solutions setup in your .gclient file.\n'
-          'Other solutions present are: %s.') % (
+      print(
+          ('You must specify the full solution name like --revision %s@%s\n'
+           'when you have multiple solutions setup in your .gclient file.\n'
+           'Other solutions present are: %s.') % (
               client.dependencies[0].name,
               options.revisions[0],
-              ', '.join(s.name for s in client.dependencies[1:]))
+              ', '.join(s.name for s in client.dependencies[1:])),
+          file=sys.stderr)
     return client
 
   def SetDefaultConfig(self, solution_name, deps_file, solution_url,
                        safesync_url, managed=True, cache_dir=None):
     self.SetConfig(self.DEFAULT_CLIENT_FILE_TEXT % {
       'solution_name': solution_name,
       'solution_url': solution_url,
       'deps_file': deps_file,
       'safesync_url' : safesync_url,
       'managed': managed,
@@ skipping 103 matching lines @@
         pm = Progress('Syncing projects', 1)
       elif command == 'recurse':
         pm = Progress(' '.join(args), 1)
     work_queue = gclient_utils.ExecutionQueue(
         self._options.jobs, pm, ignore_requirements=ignore_requirements,
         verbose=self._options.verbose)
     for s in self.dependencies:
       work_queue.enqueue(s)
     work_queue.flush(revision_overrides, command, args, options=self._options)
     if revision_overrides:
-      print >> sys.stderr, ('Please fix your script, having invalid '
-                            '--revision flags will soon considered an error.')
+      print('Please fix your script, having invalid --revision flags will soon '
+            'considered an error.', file=sys.stderr)
 
     # Once all the dependencies have been processed, it's now safe to run the
     # hooks.
     if not self._options.nohooks:
       self.RunHooksRecursively(self._options)
 
     if command == 'update':
       # Notify the user if there is an orphaned entry in their working copy.
       # Only delete the directory if there are no changes in it, and
       # delete_unversioned_trees is set to true.
@@ skipping 222 matching lines @@
   parser.add_option('-s', '--scm', action='append', default=[],
                     help='Choose scm types to operate upon.')
   parser.add_option('-i', '--ignore', action='store_true',
                     help='Ignore non-zero return codes from subcommands.')
   parser.add_option('--prepend-dir', action='store_true',
                     help='Prepend relative dir for use with git <cmd> --null.')
   parser.add_option('--no-progress', action='store_true',
                     help='Disable progress bar that shows sub-command updates')
   options, args = parser.parse_args(args)
   if not args:
-    print >> sys.stderr, 'Need to supply a command!'
+    print('Need to supply a command!', file=sys.stderr)
     return 1
   root_and_entries = gclient_utils.GetGClientRootAndEntries()
   if not root_and_entries:
-    print >> sys.stderr, (
+    print(
         'You need to run gclient sync at least once to use \'recurse\'.\n'
-        'This is because .gclient_entries needs to exist and be up to date.')
+        'This is because .gclient_entries needs to exist and be up to date.',
+        file=sys.stderr)
     return 1
 
   # Normalize options.scm to a set()
   scm_set = set()
   for scm in options.scm:
     scm_set.update(scm.split(','))
   options.scm = scm_set
 
   options.nohooks = True
   client = GClient.LoadCurrentConfig(options)
@@ skipping 13 matching lines @@
 
 
 def CMDgrep(parser, args):
   """Greps through git repos managed by gclient.
 
   Runs 'git grep [args...]' for each module.
   """
   # We can't use optparse because it will try to parse arguments sent
   # to git grep and throw an error. :-(
   if not args or re.match('(-h|--help)$', args[0]):
-    print >> sys.stderr, (
+    print(
         'Usage: gclient grep [-j <N>] git-grep-args...\n\n'
         'Example: "gclient grep -j10 -A2 RefCountedBase" runs\n"git grep '
         '-A2 RefCountedBase" on each of gclient\'s git\nrepos with up to '
         '10 jobs.\n\nBonus: page output by appending "|& less -FRSX" to the'
-        ' end of your query.'
-        )
+        ' end of your query.',
+        file=sys.stderr)
     return 1
 
   jobs_arg = ['--jobs=1']
   if re.match(r'(-j|--jobs=)\d+$', args[0]):
     jobs_arg, args = args[:1], args[1:]
   elif re.match(r'(-j|--jobs)$', args[0]):
     jobs_arg, args = args[:2], args[2:]
 
   return CMDrecurse(
       parser,
@@ skipping 347 matching lines @@
 
 
 def CMDhookinfo(parser, args):
   """Outputs the hooks that would be run by `gclient runhooks`."""
   (options, args) = parser.parse_args(args)
   options.force = True
   client = GClient.LoadCurrentConfig(options)
   if not client:
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
   client.RunOnDeps(None, [])
-  print '; '.join(' '.join(hook) for hook in client.GetHooks(options))
+  print('; '.join(' '.join(hook) for hook in client.GetHooks(options)))
   return 0
 
 
 def CMDverify(parser, args):
   """Verifies the DEPS file deps are only from allowed_hosts."""
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
   client.RunOnDeps(None, [])
   # Look at each first-level dependency of this gclient only.
   for dep in client.dependencies:
     bad_deps = dep.findDepsFromNotAllowedHosts()
     if not bad_deps:
       continue
-    print "There are deps from not allowed hosts in file %s" % dep.deps_file
+    print("There are deps from not allowed hosts in file %s" % dep.deps_file)
     for bad_dep in bad_deps:
-      print "\t%s at %s" % (bad_dep.name, bad_dep.url)
-    print "allowed_hosts:", ', '.join(dep.allowed_hosts)
+      print("\t%s at %s" % (bad_dep.name, bad_dep.url))
+    print("allowed_hosts:", ', '.join(dep.allowed_hosts))
     sys.stdout.flush()
     raise gclient_utils.Error(
         'dependencies from disallowed hosts; check your DEPS file.')
   return 0
 
 class OptionParser(optparse.OptionParser):
   gclientfile_default = os.environ.get('GCLIENT_FILE', '.gclient')
 
   def __init__(self, **kwargs):
     optparse.OptionParser.__init__(
@@ skipping 72 matching lines @@
   # operations. Python as a strong tendency to buffer sys.stdout.
   sys.stdout = gclient_utils.MakeFileAutoFlush(sys.stdout)
   # Make stdout annotated with the thread ids.
   sys.stdout = gclient_utils.MakeFileAnnotated(sys.stdout)
 
 
 def main(argv):
   """Doesn't parse the arguments here, just find the right subcommand to
   execute."""
   if sys.hexversion < 0x02060000:
-    print >> sys.stderr, (
+    print(
         '\nYour python version %s is unsupported, please upgrade.\n' %
-        sys.version.split(' ', 1)[0])
+        sys.version.split(' ', 1)[0],
+        file=sys.stderr)
     return 2
   if not sys.executable:
-    print >> sys.stderr, (
-        '\nPython cannot find the location of it\'s own executable.\n')
+    print(
+        '\nPython cannot find the location of it\'s own executable.\n',
+        file=sys.stderr)
     return 2
   fix_encoding.fix_encoding()
   disable_buffering()
   colorama.init()
   dispatcher = subcommand.CommandDispatcher(__name__)
   try:
     return dispatcher.execute(OptionParser(), argv)
   except KeyboardInterrupt:
     gclient_utils.GClientChildren.KillAllRemainingChildren()
     raise
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
-    print >> sys.stderr, 'Error: %s' % str(e)
+    print('Error: %s' % str(e), file=sys.stderr)
     return 1
   finally:
     gclient_utils.PrintWarnings()
   return 0
 
 
 if '__main__' == __name__:
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: