Add simple depends_on API.

recipe_engine/loader.py

 # Copyright 2013-2015 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 collections
 import contextlib
 import imp
 import inspect
 import os
 import sys
@@ skipping 113 matching lines @@
   # TODO(luqui): Forbid depending on a module from a (locally) undeclared
   # dependency.
   def __init__(self, package, module, local_name, universe):
     mod_path = (
         universe.package_deps.get_package(package).module_path(module))
     super(PackageDependency, self).__init__(
         mod_path, local_name, universe=universe)
 
 
 class RecipeUniverse(object):
-  def __init__(self, package_deps):
+  def __init__(self, package_deps, config_file):
     self._loaded = {}
     self._package_deps = package_deps
+    self._config_file = config_file
+
+  @property
+  def config_file(self):
+    return self._config_file
 
   @property
   def module_dirs(self):
     return self._package_deps.all_module_dirs
 
   @property
   def recipe_dirs(self):
     return self._package_deps.all_recipe_dirs
 
   @property
@@ skipping 252 matching lines @@
     self._instances = {}
 
   def instantiate(self, mod):
     if mod in self._instances:
       return self._instances[mod]
     deps_dict = { name: self.instantiate(dep)
                   for name, dep in mod.LOADED_DEPS.iteritems() }
     self._instances[mod] = self._instantiator(mod, deps_dict)
     return self._instances[mod]
 
+def _invoke_with_properties(callable_obj, all_props, prop_defs, arg_names,
+                            **additional_args):
+  """Internal version of invoke_with_properties.
+
+  The main difference is it gets passed the argument names in as an argument.
+  This allows us to reuse this logic elsewhere, without defining a fake function
+  which has arbitrary argument names.
+  """
+  for name, prop in prop_defs.items():
+    if not isinstance(prop, BoundProperty):
+      raise ValueError(
+          "You tried to invoke {} with an unbound Property {} named {}".format(
+              callable, prop, name))
+
+  props = []
+  for arg in arg_names:
+    if arg in additional_args:
+      props.append(additional_args.pop(arg))
+      continue
+
+    if arg not in prop_defs:
+      raise UndefinedPropertyException(
+        "Missing property definition for '{}'.".format(arg))
+
+    prop = prop_defs[arg]
+    props.append(prop.interpret(all_props.get(
+      prop.param_name, PROPERTY_SENTINEL)))
+
+  return callable_obj(*props, **additional_args)
+
 def invoke_with_properties(callable_obj, all_props, prop_defs,
                            **additional_args):
   """
   Invokes callable with filtered, type-checked properties.
 
   Args:
     callable_obj: The function to call, or class to instantiate.
                   This supports passing in either RunSteps, or a recipe module,
                   which is a class.
     all_props: A dictionary containing all the properties (instances of BoundProperty)
                currently defined in the system.
     prop_defs: A dictionary of name to property definitions for this callable.
     additional_args: kwargs to pass through to the callable.
                      Note that the names of the arguments can correspond to
                      positional arguments as well.
 
   Returns:
     The result of calling callable with the filtered properties
     and additional arguments.
   """
   # Check that we got passed BoundProperties, and not Properties
 
-  for name, prop in prop_defs.items():
-    if not isinstance(prop, BoundProperty):
-      raise ValueError(
-          "You tried to invoke {} with an unbound Property {} named {}".format(
-              callable, prop, name))
 
   # To detect when they didn't specify a property that they have as a
   # function argument, list the arguments, through inspection,
   # and then comparing this list to the provided properties. We use a list
   # instead of a dict because getargspec returns a list which we would have to
   # convert to a dictionary, and the benefit of the dictionary is pretty small.
-  props = []
   if inspect.isclass(callable_obj):
     arg_names = inspect.getargspec(callable_obj.__init__).args
 
     arg_names.pop(0)
   else:
     arg_names = inspect.getargspec(callable_obj).args
+  return _invoke_with_properties(callable_obj, all_props, prop_defs, arg_names,
+                                 **additional_args)
 
-  for arg in arg_names:
-    if arg in additional_args:
-      props.append(additional_args.pop(arg))
-      continue
-
-    if arg not in prop_defs:
-      raise UndefinedPropertyException(
-        "Missing property definition for '{}'.".format(arg))
-
-    prop = prop_defs[arg]
-    props.append(prop.interpret(all_props.get(
-      prop.param_name, PROPERTY_SENTINEL)))
-
-  return callable_obj(*props, **additional_args)
 
 def create_recipe_api(toplevel_deps, engine, test_data=DisabledTestData()):
   def instantiator(mod, deps):
     kwargs = {
       'module': mod,
       'engine': engine,
       # TODO(luqui): test_data will need to use canonical unique names.
       'test_data': test_data.get_module_test_data(mod.NAME)
     }
     prop_defs = mod.PROPERTIES
@@ skipping 22 matching lines @@
     return modapi
 
   mapper = DependencyMapper(instantiator)
   api = RecipeTestApi(module=None)
   for k,v in toplevel_deps.iteritems():
     setattr(api, k, mapper.instantiate(v))
   return api