- The ``repoze.bfg.templating`` module now uses ``pkg_resources`` to

  locate and register template files instead of using an absolute
  path name.

4 files changed, 93 insertions, 35 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index 94a17563d..72933f90e 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -7,6 +7,10 @@ Features
 - Use the ``pkg_resources`` API to locate template filenames instead
   of dead-reckoning using the ``os.path`` module.
 
+- The ``repoze.bfg.templating`` module now uses ``pkg_resources`` to
+  locate and register template files instead of using an absolute
+  path name.
+
 1.0a4 (2009-06-25)
 ==================
 
diff --git a/repoze/bfg/path.py b/repoze/bfg/path.py
index d8e90f0ff..5b827f04b 100644
--- a/repoze/bfg/path.py
+++ b/repoze/bfg/path.py
@@ -3,6 +3,7 @@ import sys
 import pkg_resources
 
 def caller_path(path, level=2):
+    """ Return an absolute path """
     if not os.path.isabs(path):
         module = caller_module(level+1)
         prefix = package_path(module)
diff --git a/repoze/bfg/templating.py b/repoze/bfg/templating.py
index ce2833415..337621eef 100644
--- a/repoze/bfg/templating.py
+++ b/repoze/bfg/templating.py
@@ -1,24 +1,39 @@
+import pkg_resources
 from zope.component import queryUtility
 from repoze.bfg.interfaces import ITemplateRenderer
 from zope.component import getSiteManager
-from repoze.bfg.path import caller_path
+from repoze.bfg.path import caller_module
 import os
 
 def renderer_from_cache(path, factory, level=3, **kw):
-    abspath = caller_path(path, level=level)
-    renderer = queryUtility(ITemplateRenderer, abspath)
+    if os.path.isabs(path):
+        # 'path' is an absolute filename (not common and largely only
+        # for backwards compatibility)
+        if not os.path.exists(path):
+            raise ValueError('Missing template file: %s' % path)
+        renderer = queryUtility(ITemplateRenderer, name=path)
+        if renderer is None:
+            renderer = factory(path, **kw)
+            sm = getSiteManager()
+            sm.registerUtility(renderer, ITemplateRenderer, name=path)
 
-    if renderer is None:
-        # service unit tests and explicit registrations by trying the relative
-        # "path"
-        renderer = queryUtility(ITemplateRenderer, path)
-
-    if renderer is None:
-        if not os.path.exists(abspath):
-            raise ValueError('Missing template file: %s' % abspath)
-        renderer = factory(abspath, **kw)
-        sm = getSiteManager()
-        sm.registerUtility(renderer, ITemplateRenderer, name=abspath)
+    else:
+        # 'path' is a relative filename
+        module = caller_module(level=level)
+        spec = (module.__name__, path) 
+        utility_name = '%s\t%s' % spec # utility name must be a string :-(
+        renderer = queryUtility(ITemplateRenderer, name=utility_name)
+        if renderer is None:
+            # service unit tests here by trying the relative path
+            # string as the utility name directly
+            renderer = queryUtility(ITemplateRenderer, name=path)
+        if renderer is None:
+            if not pkg_resources.resource_exists(*spec):
+                raise ValueError('Missing template resource: %s:%s' % spec)
+            abspath = pkg_resources.resource_filename(*spec)
+            renderer = factory(abspath, **kw)
+            sm = getSiteManager()
+            sm.registerUtility(renderer, ITemplateRenderer, name=utility_name)
         
     return renderer
 
diff --git a/repoze/bfg/tests/test_templating.py b/repoze/bfg/tests/test_templating.py
index 94d7a21f9..57c6d0866 100644
--- a/repoze/bfg/tests/test_templating.py
+++ b/repoze/bfg/tests/test_templating.py
@@ -14,42 +14,80 @@ class TestRendererFromCache(unittest.TestCase):
         from repoze.bfg.templating import renderer_from_cache
         return renderer_from_cache(path, factory, level, **kw)
 
-    def test_relpath_found(self):
-        renderer = {}
+    def test_abspath_notfound(self):
         from repoze.bfg.interfaces import ITemplateRenderer
-        testing.registerUtility(renderer, ITemplateRenderer, name='foo/bar')
-        result = self._callFUT('foo/bar', None)
-        self.failUnless(renderer is result)
+        abspath = '/wont/exist'
+        testing.registerUtility({}, ITemplateRenderer, name=abspath)
+        self.assertRaises(ValueError, self._callFUT, abspath, None)
 
-    def test_abspath_found(self):
+    def test_abspath_alreadyregistered(self):
+        from repoze.bfg.interfaces import ITemplateRenderer
         import os
-        here = os.path.dirname(__file__)
-        abspath = os.path.join(here, 'foo/bar')
+        abspath = os.path.abspath(__file__)
+        renderer = {}
+        testing.registerUtility(renderer, ITemplateRenderer, name=abspath)
+        result = self._callFUT(abspath, None)
+        self.failUnless(result is renderer)
+
+    def test_abspath_notyetregistered(self):
         from repoze.bfg.interfaces import ITemplateRenderer
+        import os
+        abspath = os.path.abspath(__file__)
         renderer = {}
         testing.registerUtility(renderer, ITemplateRenderer, name=abspath)
+        result = self._callFUT(abspath, None)
+        self.failUnless(result is renderer)
+
+    def test_relpath_path_registered(self):
+        renderer = {}
+        from repoze.bfg.interfaces import ITemplateRenderer
+        testing.registerUtility(renderer, ITemplateRenderer, name='foo/bar')
         result = self._callFUT('foo/bar', None)
         self.failUnless(renderer is result)
 
-    def test_notfound_missing(self):
+    def test_relpath_notfound(self):
         import os
         here = os.path.dirname(__file__)
-        abspath = os.path.join(here, 'foo/bar')
-        renderer = {}
-        self.assertRaises(ValueError, self._callFUT, 'foo/bar', None)
-        
-    def test_withfactory(self):
+        abspath = os.path.join(here, 'wont/exist')
         renderer = {}
-        factory = DummyFactory(renderer)
+        self.assertRaises(ValueError, self._callFUT, 'wont/exist', None)
+
+    def test_relpath_alreadyregistered(self):
+        from repoze.bfg.interfaces import ITemplateRenderer
         import os
-        here = os.path.dirname(__file__)
-        abspath = os.path.join(here, 'fixtures/pp.pt')
+        from repoze.bfg.tests import test_templating
+        module_name = test_templating.__name__
+        relpath = 'test_templating.py'
+        spec = '%s\t%s' % (module_name, relpath)
+        renderer = {}
+        testing.registerUtility(renderer, ITemplateRenderer, name=spec)
+        result = self._callFUT('test_templating.py', None)
+        self.failUnless(result is renderer)
+
+    def test_relpath_notyetregistered(self):
         from repoze.bfg.interfaces import ITemplateRenderer
-        testing.registerUtility(renderer, ITemplateRenderer, name=abspath)
-        result = self._callFUT('fixtures/pp.pt', factory)
-        self.failUnless(renderer is result)
-        
+        import os
+        from repoze.bfg.tests import test_templating
+        module_name = test_templating.__name__
+        relpath = 'test_templating.py'
+        spec = '%s\t%s' % (module_name, relpath)
+        renderer = {}
+        factory = DummyFactory(renderer)
+        result = self._callFUT('test_templating.py', factory)
+        self.failUnless(result is renderer)
+        path = os.path.abspath(__file__)
+        if path.endswith('pyc'): # pragma: no cover
+            path = path[:-1]
+        self.assertEqual(factory.path, path)
+        self.assertEqual(factory.kw, {})
+
 class DummyFactory:
     def __init__(self, renderer):
         self.renderer = renderer
 
+    def __call__(self, path, **kw):
+        self.path = path
+        self.kw = kw
+        return self.renderer
+    
+