Changed recipe_modules base paths to be abstract entities in their own right.

scripts/slave/recipe_config_types.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 abc
 import re
 
+from collections import namedtuple
+
 from infra.libs import infra_types
 
 def ResetTostringFns():
   RecipeConfigType._TOSTRING_MAP.clear()  # pylint: disable=W0212
 
 
 def json_fixup(obj):
   if isinstance(obj, RecipeConfigType):
     return str(obj)
   thawed = infra_types.thaw(obj)
@@ skipping 36 matching lines @@
         'tostring_fn already installed for %s' % cls)
     cls._TOSTRING_MAP[cls.__name__] = new_tostring_fn
 
   def default_tostring_fn(self):
     raise NotImplementedError
 
   def __str__(self):
     return self.tostring_fn(self) # pylint: disable=not-callable
 
 
+class BasePath(object):
+  __metaclass__ = abc.ABCMeta
+
+
+class NamedBasePath(BasePath, namedtuple('NamedBasePath', 'name')):
+  # Restrict basenames to '[ALL_CAPS]'. This will help catch
+  # errors if someone attempts to provide an actual string path '/some/example'
+  # as the 'base'.
+  BASE_RE = re.compile(r'\[([A-Z][A-Z_]*)\]')
+
+  @staticmethod
+  def parse(base):
+    base_match = NamedBasePath.BASE_RE.match(base)
+    assert base_match, 'Base should be [ALL_CAPS], got %r' % base
+    return NamedBasePath(base_match.group(1).lower())
+
+  def __repr__(self):
+    return '[%s]' % self.name.upper()
+
+
+class ModuleBasePath(BasePath, namedtuple('ModuleBasePath', 'module')):
+  # All recipe modules are in a magic RECIPE_MODULES package.  Remove it
+  # before rendering MODULE[_] form.
+  MODULE_PREFIX_RE = r'^RECIPE_MODULES\.'
+
+  def __repr__(self):
+    name = re.sub(self.MODULE_PREFIX_RE, '', self.module.__name__)
+    return 'RECIPE_MODULE[%s]' % name
+
+
 class Path(RecipeConfigType):
   """Represents a path which is relative to a semantically-named base.
 
   Because there's a lot of platform (separator style) and runtime-specific
   context (working directory) which goes into assembling a final OS-specific
   absolute path, we only store three context-free attributes in this Path
   object.
   """
-  # Restrict basenames to '[ALL_CAPS]'. This will help catch
-  # errors if someone attempts to provide an actual string path '/some/example'
-  # as the 'base'.
-  BASE_RE = re.compile(r'\[([A-Z][A-Z_]*)\]')
 
   def __init__(self, base, *pieces, **kwargs):
     """Creates a Path
 
     Args:
       base (str) - The 'name' of a base path, to be filled in at recipe runtime
         by the 'path' recipe module.
       pieces (tuple(str)) - The components of the path relative to base. These
         pieces must be non-relative (i.e. no '..' or '.', etc. as a piece).
 
     Kwargs:
       platform_ext (dict(str, str)) - A mapping from platform name (as defined
         by the 'platform' module), to a suffix for the path.
-      _bypass (bool) - Bypass the type checking and use |base| directly. Don't
-        use this outside of the 'path' module or this class.
     """
     super(Path, self).__init__()
     assert all(isinstance(x, basestring) for x in pieces), pieces
     assert not any(x in ('..', '.', '/', '\\') for x in pieces)
     self.pieces = pieces
 
-    if kwargs.get('_bypass'):
+    if isinstance(base, BasePath):
       self.base = base
+    elif isinstance(base, basestring):
+      self.base = NamedBasePath.parse(base)
     else:
-      base_match = self.BASE_RE.match(base)
-      assert base_match, 'Base should be [ALL_CAPS], got %r' % base
-      self.base = base_match.group(1).lower()
+      raise ValueError('%s is not a valid base path' % base)
 
     self.platform_ext = kwargs.get('platform_ext', {})
 
   def __eq__(self, other):
     return (self.base == other.base and
             self.pieces == other.pieces and
             self.platform_ext == other.platform_ext)
 
   def __ne__(self, other):
     return not self.base == other
 
   def join(self, *pieces, **kwargs):
     kwargs.setdefault('platform_ext', self.platform_ext)
-    kwargs['_bypass'] = True
     return Path(self.base, *filter(bool, self.pieces + pieces), **kwargs)
 
   def is_parent_of(self, child):
     """True if |child| is in a subdirectory of this path."""
     # Assumes base paths are not nested.
     # TODO(vadimsh): We should not rely on this assumption.
     if self.base != child.base:
       return False
     # A path is not a parent to itself.
     if len(self.pieces) >= len(child.pieces):
       return False
     return child.pieces[:len(self.pieces)] == self.pieces
 
   def default_tostring_fn(self):
     suffix = ''
     if self.platform_ext:
       suffix = ', platform_ext=%r' % (self.platform_ext,)
     pieces = ''
     if self.pieces:
       pieces = ', ' + (', '.join(map(repr, self.pieces)))
-    return 'Path(\'[%s]\'%s%s)' % (self.base.upper(), pieces, suffix)
+    return 'Path(\'%s\'%s%s)' % (self.base, pieces, suffix)