Minor cleanup of some recipe framework code.

scripts/slave/recipe_util.py

 # Copyright 2013 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.
+
 import functools
 import os
 
 
 SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
 BUILD_ROOT = os.path.dirname(os.path.dirname(SCRIPT_PATH))
 ROOT_PATH = os.path.abspath(os.path.join(
   SCRIPT_PATH, os.pardir, os.pardir, os.pardir))
 BASE_DIRS = [
   SCRIPT_PATH,
   os.path.join(ROOT_PATH, 'build_internal', 'scripts', 'slave'),
   os.path.join(ROOT_PATH, 'build_internal', 'scripts', 'slave-internal')
 ]
 MODULE_DIRS = lambda: [os.path.join(x, 'recipe_modules') for x in BASE_DIRS]
 RECIPE_DIRS = lambda: [os.path.join(x, 'recipes') for x in BASE_DIRS]
 
+
 class RecipeAbort(Exception):
   pass
 
 
 class ModuleInjectionError(AttributeError):
   pass
 
 
 class ModuleInjectionSite(object):
   def __init__(self, owner_module=None):
@@ skipping 74 matching lines @@
   @static_wraps(func)
   def inner(self, *args, **kwargs):
     ret = static_call(self, func, *args, **kwargs)
     assert isinstance(ret, Placeholder)
     ret.name_pieces = (self.name, static_name(self, func))
     return ret
   return inner
 
 
 def wrap_followup(kwargs, pre=False):
-  """
-  Decorator for a new followup_fn.
+  """Decorator for a new followup_fn.
 
   Will pop the existing fn out of kwargs (if any), and return a decorator for
   the new folloup_fn.
 
   Args:
     kwargs - dictionary possibly containing folloup_fn
     pre - If true, the old folloup_fn is called before the wrapped function.
           Otherwise, the old followup_fn is called after the wrapped function.
   """
   null_fn = lambda _: None
   old_followup = kwargs.pop('followup_fn', null_fn)
   def decorator(f):
     @functools.wraps(f)
     def _inner(step_result):
       if pre:
         old_followup(step_result)
         f(step_result)
       else:
         f(step_result)
         old_followup(step_result)
     if old_followup is not null_fn:
       _inner.__name__ += '[%s]' % old_followup.__name__
     return _inner
   return decorator
 
 
+def cached_unary(f):
+  """Decorator that caches/memoizes an unary function result.
+
+  If the function throws an exception, the cache table will not be updated.
+  """
+  cache = {}
+  empty = object()
+
+  @functools.wraps(f)
+  def cached_f(inp):
+    cache_entry = cache.get(inp, empty)
+    if cache_entry is empty:
+      cache_entry = f(inp)
+      cache[inp] = cache_entry
+    return cache_entry
+  return cached_f
+
+
+def scan_directory(path, predicate):
+  """Recursively scans a directory and yields paths that match predicate."""
+  for root, _dirs, files in os.walk(path):
+    for file_name in (f for f in files if predicate(f)):
+      file_path = os.path.join(root, file_name)
+      yield file_path