Revamped terminal output for update.

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 426 matching lines @@
       if not parsed_url[0]:
         # A relative url. Fetch the real base.
         path = parsed_url[2]
         if not path.startswith('/'):
           raise gclient_utils.Error(
               'relative DEPS entry \'%s\' must begin with a slash' % url)
         # Create a scm just to query the full url.
         parent_url = self.parent.parsed_url
         if isinstance(parent_url, self.FileImpl):
           parent_url = parent_url.file_location
-        scm = gclient_scm.CreateSCM(parent_url, self.root.root_dir, None)
+        scm = gclient_scm.CreateSCM(
+            parent_url, self.root.root_dir, None, self.outbuf)
         parsed_url = scm.FullUrlForRelativeUrl(url)
       else:
         parsed_url = url
       logging.info(
           'Dependency(%s).LateOverride(%s) -> %s' %
           (self.name, url, parsed_url))
       return parsed_url
 
     if isinstance(url, self.FileImpl):
       logging.info(
@@ skipping 192 matching lines @@
     parsed_url = self.LateOverride(self.url)
     file_list = [] if not options.nohooks else None
     if run_scm and parsed_url:
       if isinstance(parsed_url, self.FileImpl):
         # Special support for single-file checkout.
         if not command in (None, 'cleanup', 'diff', 'pack', 'status'):
           # Sadly, pylint doesn't realize that parsed_url is of FileImpl.
           # pylint: disable=E1103
           options.revision = parsed_url.GetRevision()
           self._used_scm = gclient_scm.SVNWrapper(
-              parsed_url.GetPath(), self.root.root_dir, self.name)
+              parsed_url.GetPath(), self.root.root_dir, self.name,
+              out_cb=work_queue.out_cb)
           self._used_scm.RunCommand('updatesingle',
               options, args + [parsed_url.GetFilename()], file_list)
       else:
         # Create a shallow copy to mutate revision.
         options = copy.copy(options)
         options.revision = revision_overrides.get(self.name)
         self.maybeGetParentRevision(
             command, options, parsed_url, self.parent.name, revision_overrides)
         self._used_scm = gclient_scm.CreateSCM(
-            parsed_url, self.root.root_dir, self.name)
+            parsed_url, self.root.root_dir, self.name, self.outbuf,
+            out_cb=work_queue.out_cb)
         self._got_revision = self._used_scm.RunCommand(command, options, args,
                                                        file_list)
         if file_list:
           file_list = [os.path.join(self.name, f.strip()) for f in file_list]
 
       # TODO(phajdan.jr): We should know exactly when the paths are absolute.
       # Convert all absolute paths to relative.
       for i in range(len(file_list or [])):
         # It depends on the command being executed (like runhooks vs sync).
         if not os.path.isabs(file_list[i]):
@@ skipping 36 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' % 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])
               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)
               else:
@@ skipping 305 matching lines @@
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
     self._enforced_os = tuple(set(enforced_os))
     self._root_dir = root_dir
     self.config_content = None
 
   def _CheckConfig(self):
     """Verify that the config matches the state of the existing checked-out
     solutions."""
     for dep in self.dependencies:
       if dep.managed and dep.url:
-        scm = gclient_scm.CreateSCM(dep.url, self.root_dir, dep.name)
+        scm = gclient_scm.CreateSCM(
+            dep.url, self.root_dir, dep.name, self.outbuf)
         actual_url = scm.GetActualRemoteURL()
         if actual_url and not scm.DoesRemoteURLMatch():
           raise gclient_utils.Error('''
 Your .gclient file seems to be broken. The requested URL is different from what
 is actually checked out in %(checkout_path)s.
 
 Expected: %(expected_url)s (%(expected_scm)s)
 Actual:   %(actual_url)s (%(actual_scm)s)
 
 You should ensure that the URL listed in .gclient is correct and either change
@@ skipping 160 matching lines @@
     be invalid for the given |dep|."""
     assert len(dep.safesync_url) > 0
     handle = urllib.urlopen(dep.safesync_url)
     rev = handle.read().strip()
     handle.close()
     if not rev:
       raise gclient_utils.Error(
           'It appears your safesync_url (%s) is not working properly\n'
           '(as it returned an empty response). Check your config.' %
           dep.safesync_url)
-    scm = gclient_scm.CreateSCM(dep.url, dep.root.root_dir, dep.name)
+    scm = gclient_scm.CreateSCM(
+        dep.url, dep.root.root_dir, dep.name, self.outbuf)
     safe_rev = scm.GetUsableRev(rev, self._options)
     if self._options.verbose:
       print('Using safesync_url revision: %s.\n' % safe_rev)
     self._options.revisions.append('%s@%s' % (dep.name, safe_rev))
 
   def RunOnDeps(self, command, args, ignore_requirements=False, progress=True):
     """Runs a command on each dependency in a client and its dependencies.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
@@ skipping 10 matching lines @@
     if command not in ('diff', 'recurse', 'runhooks', 'status'):
       revision_overrides = self._EnforceRevisions()
     pm = None
     # Disable progress for non-tty stdout.
     if (sys.stdout.isatty() and not self._options.verbose and progress):
       if command in ('update', 'revert'):
         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)
+        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)
 
     # 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':
@@ skipping 15 matching lines @@
         def _IsParentOfAny(parent, path_list):
           parent_plus_slash = parent + '/'
           return any(
               path[:len(parent_plus_slash)] == parent_plus_slash
               for path in path_list)
 
         # Use entry and not entry_fixed there.
         if (entry not in entries and
             (not any(path.startswith(entry + '/') for path in entries)) and
             os.path.exists(e_dir)):
-          scm = gclient_scm.CreateSCM(prev_url, self.root_dir, entry_fixed)
+          scm = gclient_scm.CreateSCM(
+              prev_url, self.root_dir, entry_fixed, self.outbuf)
 
           # Check to see if this directory is now part of a higher-up checkout.
           if scm.GetCheckoutRoot() in full_entries:
             logging.info('%s is part of a higher level checkout, not '
                          'removing.', scm.GetCheckoutRoot())
             continue
 
           file_list = []
           scm.status(self._options, [], file_list)
           modified_files = file_list != []
@@ skipping 10 matching lines @@
                 entry_fixed, self.root_dir))
             gclient_utils.rmtree(e_dir)
       # record the current list of entries for next time
       self._SaveEntries()
     return 0
 
   def PrintRevInfo(self):
     if not self.dependencies:
       raise gclient_utils.Error('No solution specified')
     # Load all the settings.
-    work_queue = gclient_utils.ExecutionQueue(self._options.jobs, None, False)
+    work_queue = gclient_utils.ExecutionQueue(
+        self._options.jobs, None, False, verbose=self._options.verbose)
     for s in self.dependencies:
       work_queue.enqueue(s)
     work_queue.flush({}, None, [], options=self._options)
 
     def GetURLAndRev(dep):
       """Returns the revision-qualified SCM url for a Dependency."""
       if dep.parsed_url is None:
         return None
       if isinstance(dep.parsed_url, self.FileImpl):
         original_url = dep.parsed_url.file_location
       else:
         original_url = dep.parsed_url
       url, _ = gclient_utils.SplitUrlRevision(original_url)
-      scm = gclient_scm.CreateSCM(original_url, self.root_dir, dep.name)
+      scm = gclient_scm.CreateSCM(
+          original_url, self.root_dir, dep.name, self.outbuf)
       if not os.path.isdir(scm.checkout_path):
         return None
       return '%s@%s' % (url, scm.revinfo(self._options, [], None))
 
     if self._options.snapshot:
       new_gclient = ''
       # First level at .gclient
       for d in self.dependencies:
         entries = {}
         def GrabDeps(dep):
@@ skipping 595 matching lines @@
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
   finally:
     gclient_utils.PrintWarnings()
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: