[loader] Make recipe engine support examples/ module subdir

recipe_modules/path/api.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import functools
 import itertools
 import os
+import re
 import tempfile
 
 from recipe_engine import recipe_api
 from recipe_engine import config_types
 
 
 class Error(Exception):
   """Error specific to path recipe module."""
 
 
@@ skipping 47 matching lines @@
   current platform according to the `platform` module. This allows us to
   simulate path functions according to the platform being tested, rather than
   the platform which is currently running.
   """
 
   def __init__(self, api, _mock_path_exists):
     self._api = api
     self._mock_path_exists = path_set(self, _mock_path_exists)
     self._pth = None
 
-  def __getattr__(self, name):
+  def _init_pth(self):
     if not self._pth:
       if self._api.m.platform.is_win:
         import ntpath as pth
       elif self._api.m.platform.is_mac or self._api.m.platform.is_linux:
         import posixpath as pth
       self._pth = pth
+
+  def __getattr__(self, name):
+    self._init_pth()
     return getattr(self._pth, name)
 
   def mock_add_paths(self, path):
     """
     Adds a path and all of its parents to the set of existing paths.
     """
     self._mock_path_exists.add(path)
 
   def exists(self, path):  # pylint: disable=E0202
     """Return True if path refers to an existing path."""
     return self._mock_path_exists.contains(path)
 
+  # This matches:
+  #   [START_DIR]
+  #   RECIPE[some_pkg::some_module:recipe_name]
+  #
+  # and friends at the beginning of a string.
+  ROOT_MATCHER = re.compile('^[A-Z_]*\[[^]]*\]')
+
+  def normpath(self, path):
+    """Normalizese the path.
+
+    This splits off a recipe base (i.e. RECIPE[...]) so that normpath is
+    only called on the user-supplied portion of the path.
+    """
+    self._init_pth()
+    real_normpath = self._pth.normpath
+    m = self.ROOT_MATCHER.match(path)
+    if m:
+      prefix = m.group(0)
+      rest = path[len(prefix):]
+      if rest == '':
+        # normpath turns '' into '.'
+        return prefix
+      return prefix + real_normpath(rest)
+    return real_normpath(path)
+
   def abspath(self, path):
     """Returns the absolute version of path."""
     return self.normpath(path)
 
   def realpath(self, path):
     """Returns the canonical version of the path."""
     return self.normpath(path)
 
   def expanduser(self, path):
     return path.replace('~', '[HOME]')
@@ skipping 145 matching lines @@
     Example:
     ```
       # assume [START_DIR] == "/basis/dir/for/recipe"
       api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->
         Path("[START_DIR]/some/other/dir")
     ```
 
     Raises an ValueError if the preconditions are not met, otherwise returns the
     Path object.
     """
-    if self.abspath(abs_string_path) != abs_string_path:
-      raise ValueError("path is not absolute: %r" % abs_string_path)
+    ap = self.abspath(abs_string_path)
+    if ap != abs_string_path:
+      raise ValueError("path is not absolute: %r v %r" % (abs_string_path, ap))
 
     # try module/recipe/package resource paths first
     sPath, path = self._paths_client.find_longest_prefix(
         abs_string_path, self.sep)
     if path is None:
       # try base paths now
       for path_name in itertools.chain(self.c.dynamic_paths, self.c.base_paths):
         path = self[path_name]
         sPath = str(path)
         if abs_string_path.startswith(sPath):
@@ skipping 31 matching lines @@
     if name in self.OK_ATTRS:
       return getattr(self._path_mod, name)
     if name in self.FILTER_METHODS:
       return string_filter(getattr(self._path_mod, name))
     raise AttributeError("'%s' object has no attribute '%s'" %
                          (self._path_mod, name))  # pragma: no cover
 
   def __dir__(self):  # pragma: no cover
     # Used for helping out show_me_the_modules.py
     return self.__dict__.keys() + list(self.OK_ATTRS + self.FILTER_METHODS)