Add gclient grep for git repos

gclient_utils.py

 # 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.
 
 """Generic utils."""
 
 import codecs
 import errno
 import logging
 import os
@@ skipping 174 matching lines @@
       os.makedirs(tree)
     except OSError, e:
       # 17 POSIX, 183 Windows
       if e.errno not in (17, 183):
         raise
       if count > 40:
         # Give up.
         raise
 
 
-def CheckCallAndFilterAndHeader(args, always=False, **kwargs):
+def CheckCallAndFilterAndHeader(args, always=False, header=None, **kwargs):
   """Adds 'header' support to CheckCallAndFilter.
 
   If |always| is True, a message indicating what is being done
   is printed to stdout all the time even if not output is generated. Otherwise
   the message header is printed only if the call generated any ouput.
   """
-  stdout = kwargs.get('stdout', None) or sys.stdout
+  stdout = kwargs.setdefault('stdout', sys.stdout)
+  if header is None:
+    header = "\n________ running '%s' in '%s'\n" % (
+                 ' '.join(args), kwargs.get('cwd', '.'))
+
   if always:
-    stdout.write('\n________ running \'%s\' in \'%s\'\n'
-        % (' '.join(args), kwargs.get('cwd', '.')))
+    stdout.write(header)
   else:
-    filter_fn = kwargs.get('filter_fn', None)
+    filter_fn = kwargs.get('filter_fn')
     def filter_msg(line):
       if line is None:
-        stdout.write('\n________ running \'%s\' in \'%s\'\n'
-            % (' '.join(args), kwargs.get('cwd', '.')))
+        stdout.write(header)
       elif filter_fn:
         filter_fn(line)
     kwargs['filter_fn'] = filter_msg
     kwargs['call_filter_on_first_line'] = True
   # Obviously.
-  kwargs['print_stdout'] = True
+  kwargs.setdefault('print_stdout', True)
   return CheckCallAndFilter(args, **kwargs)
 
 
 class Wrapper(object):
   """Wraps an object, acting as a transparent proxy for all properties by
   default.
   """
   def __init__(self, wrapped):
     self._wrapped = wrapped
 
@@ skipping 215 matching lines @@
     return None
   # If the root does not have a trailing \ or /, we add it so the returned
   # path starts immediately after the seperator regardless of whether it is
   # provided.
   root = os.path.join(root, '')
   return subpath[len(root):]
 
 
 def FindFileUpwards(filename, path=None):
   """Search upwards from the a directory (default: current) to find a file.
-  
+
   Returns nearest upper-level directory with the passed in file.
   """
   if not path:
     path = os.getcwd()
   path = os.path.realpath(path)
   while True:
     file_path = os.path.join(path, filename)
     if os.path.exists(file_path):
       return path
     (new_path, _) = os.path.split(path)
@@ skipping 55 matching lines @@
 class ExecutionQueue(object):
   """Runs a set of WorkItem that have interdependencies and were WorkItem are
   added as they are processed.
 
   In gclient's case, Dependencies sometime needs to be run out of order due to
   From() keyword. This class manages that all the required dependencies are run
   before running each one.
 
   Methods of this class are thread safe.
   """
-  def __init__(self, jobs, progress):
+  def __init__(self, jobs, progress, ignore_requirements):
     """jobs specifies the number of concurrent tasks to allow. progress is a
     Progress instance."""
     # Set when a thread is done or a new item is enqueued.
     self.ready_cond = threading.Condition()
     # Maximum number of concurrent tasks.
     self.jobs = jobs
     # List of WorkItem, for gclient, these are Dependency instances.
     self.queued = []
     # List of strings representing each Dependency.name that was run.
     self.ran = []
     # List of items currently running.
     self.running = []
     # Exceptions thrown if any.
     self.exceptions = Queue.Queue()
     # Progress status
     self.progress = progress
     if self.progress:
       self.progress.update(0)
 
+    self.ignore_requirements = ignore_requirements
+
   def enqueue(self, d):
     """Enqueue one Dependency to be executed later once its requirements are
     satisfied.
     """
     assert isinstance(d, WorkItem)
     self.ready_cond.acquire()
     try:
       self.queued.append(d)
       total = len(self.queued) + len(self.ran) + len(self.running)
       logging.debug('enqueued(%s)' % d.name)
@@ skipping 17 matching lines @@
             self.queued = []
           self._flush_terminated_threads()
           if (not self.queued and not self.running or
               self.jobs == len(self.running)):
             logging.debug('No more worker threads or can\'t queue anything.')
             break
 
           # Check for new tasks to start.
           for i in xrange(len(self.queued)):
             # Verify its requirements.
-            for r in self.queued[i].requirements:
-              if not r in self.ran:
-                # Requirement not met.
-                break
-            else:
+            if (self.ignore_requirements or
+                not (set(self.queued[i].requirements) - set(self.ran))):
               # Start one work item: all its requirements are satisfied.
               self._run_one_task(self.queued.pop(i), args, kwargs)
               break
           else:
             # Couldn't find an item that could run. Break out the outher loop.
             break
 
         if not self.queued and not self.running:
           # We're done.
           break
@@ skipping 175 matching lines @@
 
   Python on OSX 10.6 raises a NotImplementedError exception.
   """
   try:
     import multiprocessing
     return multiprocessing.cpu_count()
   except:  # pylint: disable=W0702
     # Mac OS 10.6 only
     # pylint: disable=E1101
     return int(os.sysconf('SC_NPROCESSORS_ONLN'))