Features

  - Added a ``repoze.bfg.testing`` module to attempt to make it
    slightly easier to write unittest-based automated tests of BFG
    applications.  Information about this class is in the
    documentation.

  - The default template renderer now supports testing better by
    looking for ``ITestingTemplateRenderer`` using a relative
    pathname.  This is exposed indirectly through the API named
    ``registerTemplate`` in ``repoze.bfg.testing``.

  Deprecations

  - The names ``repoze.bfg.interfaces.ITemplate`` ,
    ``repoze.bfg.interfaces.ITemplateFactory`` and
    ``repoze.bfg.interfaces.INodeTemplate`` have been deprecated.
    These should now be imported as
    ``repoze.bfg.interfaces.ITemplateRenderer`` and
    ``repoze.bfg.interfaces.ITemplateRendererFactory``, and
    ``INodeTemplateRenderer`` respectively.

  - The name ``repoze.bfg.chameleon_zpt.ZPTTemplateFactory`` is
    deprecated.  Use ``repoze.bfg.chameleon_zpt.ZPTTemplateRenderer``.

  - The name ``repoze.bfg.chameleon_genshi.GenshiTemplateFactory`` is
    deprecated.  Use
    ``repoze.bfg.chameleon_genshi.GenshiTemplateRenderer``.

  - The name ``repoze.bfg.xslt.XSLTemplateFactory`` is deprecated.
    Use ``repoze.bfg.xslt.XSLTemplateRenderer``.

1 files changed, 47 insertions, 39 deletions

diff --git a/repoze/bfg/chameleon_zpt.py b/repoze/bfg/chameleon_zpt.py
index 80669c009..c7d1d6949 100644
--- a/repoze/bfg/chameleon_zpt.py
+++ b/repoze/bfg/chameleon_zpt.py
@@ -3,22 +3,22 @@ import os
 from webob import Response
 
 from zope.component import queryUtility
-from zope.component.interfaces import ComponentLookupError
-from zope.component import getSiteManager
 
 from zope.interface import classProvides
 from zope.interface import implements
+from zope.deprecation import deprecated
 
-from repoze.bfg.path import caller_path
-from repoze.bfg.interfaces import ITemplateFactory
-from repoze.bfg.interfaces import ITemplate
+from repoze.bfg.interfaces import ITemplateRenderer
+from repoze.bfg.interfaces import ITemplateRendererFactory
 from repoze.bfg.interfaces import ISettings
 
+from repoze.bfg.templating import renderer_from_cache
+
 from chameleon.zpt.template import PageTemplateFile
 
-class ZPTTemplateFactory(object):
-    classProvides(ITemplateFactory)
-    implements(ITemplate)
+class ZPTTemplateRenderer(object):
+    classProvides(ITemplateRendererFactory)
+    implements(ITemplateRenderer)
 
     def __init__(self, path, auto_reload=False):
         try:
@@ -34,48 +34,56 @@ class ZPTTemplateFactory(object):
             else:
                 raise
 
+    def implementation(self):
+        return self.template
+    
     def __call__(self, **kw):
-        result = self.template.render(**kw)
-        return result
-
-def _get_template(path, **kw):
-    # XXX use pkg_resources
-    template = queryUtility(ITemplate, path)
-
-    if template is None:
-        if not os.path.exists(path):
-            raise ValueError('Missing template file: %s' % path)
-        settings = queryUtility(ISettings)
-        auto_reload = settings and settings.reload_templates
-        template = ZPTTemplateFactory(path, auto_reload)
-        try:
-            sm = getSiteManager()
-        except ComponentLookupError:
-            pass
-        else:
-            sm.registerUtility(template, ITemplate, name=path)
-        
-    return template
+        return self.template(**kw)
+
+ZPTTemplateFactory = ZPTTemplateRenderer
+deprecated('ZPTTemplateFactory',
+           ('repoze.bfg.chameleon_zpt.ZPTTemplateFactory should now be '
+            'imported as repoze.bfg.chameleon_zpt.ZPTTemplateRenderer'))
+
+def _auto_reload():
+    settings = queryUtility(ISettings)
+    auto_reload = settings and settings.reload_templates
+    return auto_reload
+
+def get_renderer(path):
+    """ Return a callable ``ITemplateRenderer`` object representing a
+    ``chameleon.zpt`` template at the package-relative path (may also
+    be absolute). """
+    auto_reload = _auto_reload()
+    renderer = renderer_from_cache(path, ZPTTemplateRenderer,
+                                   auto_reload=auto_reload)
+    return renderer
 
 def get_template(path):
-    """ Return a ``chameleon.zpt`` template object at the
-    package-relative path (may also be absolute)"""
-    path = caller_path(path)
-    return _get_template(path).template
+    """ Return a ``chameleon.zpt`` template at the package-relative
+    path (may also be absolute).  """
+    auto_reload = _auto_reload()
+    renderer = renderer_from_cache(path, ZPTTemplateRenderer,
+                                   auto_reload=auto_reload)
+    return renderer.implementation()
 
 def render_template(path, **kw):
     """ Render a ``chameleon.zpt`` template at the package-relative
     path (may also be absolute) using the kwargs in ``*kw`` as
     top-level names and return a string."""
-    path = caller_path(path)
-    template = get_template(path)
-    return template(**kw)
+    auto_reload = _auto_reload()
+    renderer = renderer_from_cache(path, ZPTTemplateRenderer,
+                                   auto_reload=auto_reload)
+    return renderer(**kw)
 
 def render_template_to_response(path, **kw):
     """ Render a ``chameleon.zpt`` template at the package-relative
     path (may also be absolute) using the kwargs in ``*kw`` as
-    top-level names and return a Response object."""
-    path = caller_path(path)
-    result = render_template(path, **kw)
+    top-level names and return a Response object with the body as the
+    template result. """
+    auto_reload = _auto_reload()
+    renderer = renderer_from_cache(path, ZPTTemplateRenderer,
+                                  auto_reload=auto_reload)
+    result = renderer(**kw)
     return Response(result)