Merge "c-free" branch to trunk.

8 files changed, 10 insertions, 596 deletions

diff --git a/repoze/bfg/chameleon_genshi.py b/repoze/bfg/chameleon_genshi.py
deleted file mode 100644
index 69047abc7..000000000
--- a/repoze/bfg/chameleon_genshi.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from webob import Response
-
-from zope.component import queryUtility
-
-from zope.interface import implements
-from zope.interface import classProvides
-from zope.deprecation import deprecated
-
-from repoze.bfg.interfaces import IResponseFactory
-from repoze.bfg.interfaces import ISettings
-from repoze.bfg.interfaces import ITemplateRenderer
-from repoze.bfg.interfaces import ITemplateRendererFactory
-
-from repoze.bfg.templating import renderer_from_cache
-
-from chameleon.genshi.template import GenshiTemplateFile
-
-class GenshiTemplateRenderer(object):
-    classProvides(ITemplateRendererFactory)
-    implements(ITemplateRenderer)
-
-    def __init__(self, path, auto_reload=False):
-        self.template = GenshiTemplateFile(path, auto_reload=auto_reload)
-
-    def implementation(self):
-        return self.template
-
-    def __call__(self, **kw):
-        return self.template(**kw)
-
-GenshiTemplateFactory = GenshiTemplateRenderer
-deprecated('GenshiTemplateFactory',
-           ('repoze.bfg.chameleon_genshi.GenshiTemplateFactory should now be '
-            'imported as repoze.bfg.chameleon_genshi.GenshiTemplateRenderer'))
-
-def _auto_reload():
-    settings = queryUtility(ISettings)
-    auto_reload = settings and settings.reload_templates
-    return auto_reload
-
-def get_template(path):
-    """ Return a ``chameleon.genshi`` template object at the
-    package-relative path (may also be absolute)"""
-    auto_reload = _auto_reload()
-    renderer = renderer_from_cache(path, GenshiTemplateRenderer,
-                                   auto_reload=auto_reload)
-    return renderer.implementation()
-
-def get_renderer(path):
-    """ Return a ``chameleon.genshi`` template renderer at the
-    package-relative path (may also be absolute)"""
-    auto_reload = _auto_reload()
-    renderer = renderer_from_cache(path, GenshiTemplateRenderer,
-                                   auto_reload=auto_reload)
-    return renderer
-
-def render_template(path, **kw):
-    """ Render a ``chameleon.genshi`` template at the package-relative
-    path (may also be absolute) using the kwargs in ``*kw`` as
-    top-level names and return a string."""
-    auto_reload = _auto_reload()
-    renderer = renderer_from_cache(path, GenshiTemplateRenderer,
-                                   auto_reload=auto_reload)
-    return renderer(**kw)
-
-def render_template_to_response(path, **kw):
-    """ Render a ``chameleon.genshi`` template at the package-relative
-    path (may also be absolute) using the kwargs in ``*kw`` as
-    top-level names and return a Response object."""
-    auto_reload = _auto_reload()
-    renderer = renderer_from_cache(path, GenshiTemplateRenderer,
-                                   auto_reload=auto_reload)
-    result = renderer(**kw)
-    response_factory = queryUtility(IResponseFactory, default=Response)
-    return response_factory(result)
diff --git a/repoze/bfg/interfaces.py b/repoze/bfg/interfaces.py
index 537bb4455..8f75a4f4a 100644
--- a/repoze/bfg/interfaces.py
+++ b/repoze/bfg/interfaces.py
@@ -8,13 +8,7 @@ from zope.component.interfaces import IObjectEvent
 deprecated(
     '(repoze.bfg.interfaces.ITemplate should now be imported '
     'as repoze.bfg.interfaces.ITemplateRenderer)',
-    ITemplate = 'repoze.bfg.interfaces:INodeTemplateRenderer',
-    )
-
-deprecated(
-    '(repoze.bfg.interfaces.INodeTemplate should now be imported '
-     'as repoze.bfg.interfaces.INodeTemplateRenderer)',
-    INodeTemplate = 'repoze.bfg.interfaces:INodeTemplateRenderer',
+    ITemplate = 'repoze.bfg.interfaces:ITemplateRenderer',
     )
 
 deprecated(
@@ -112,10 +106,6 @@ class ITemplateRendererFactory(Interface):
     def __call__(path, auto_reload=False):
         """ Return an object that implements ``ITemplateRenderer``  """
 
-class INodeTemplateRenderer(Interface):
-    def __call__(node, **kw):
-        """ Return a string result given a node and a template path """
-
 class ISecurityPolicy(Interface):
     """ A utility that provides a mechanism to check authorization
        using authentication data """
diff --git a/repoze/bfg/template.py b/repoze/bfg/template.py
index 68a7f34d1..ad6d50a44 100644
--- a/repoze/bfg/template.py
+++ b/repoze/bfg/template.py
@@ -2,23 +2,19 @@
 # compatibility; there are no plans to make this module itself go
 # away, but the ``get_template``, ``render_template``, and
 # ``render_template_to_response`` APIs should be imported from
-# ``repoze.bfg.chameleon_zpt`` in the future for optimum correctness,
-# while the ``render_transform`` and ``render_transform_to_response``
-# APIs should be imported from ``repoze.bfg.xslt``.
+# ``repoze.bfg.chameleon_zpt`` in the future for optimum correctness.
+# Two other functions named ``render_transform`` and
+# ``render_transform_to_response`` APIs used to be here for XSLT
+# support; those no longer exist here; you need to install and use the
+# ``repoze.bfg.xslt`` package.
 from zope.deprecation import deprecated
 
 from repoze.bfg.chameleon_zpt import get_template
 from repoze.bfg.chameleon_zpt import render_template
 from repoze.bfg.chameleon_zpt import render_template_to_response
-from repoze.bfg.xslt import render_transform
-from repoze.bfg.xslt import render_transform_to_response
 
 for name in ('get_template', 'render_template', 'render_template_to_response'):
     deprecated(name,
                ('repoze.bfg.template.%s should now be imported as '
                 'repoze.bfg.chameleon_zpt.%s' % (name, name)))
 
-for name in ('render_transform', 'render_transform_to_response'):
-    deprecated(name,
-               ('repoze.bfg.template.%s should now be imported as '
-                'repoze.bfg.xslt.%s' % (name, name)))
diff --git a/repoze/bfg/tests/test_chameleon_genshi.py b/repoze/bfg/tests/test_chameleon_genshi.py
deleted file mode 100644
index 6d62891bf..000000000
--- a/repoze/bfg/tests/test_chameleon_genshi.py
+++ /dev/null
@@ -1,187 +0,0 @@
-import unittest
-
-from zope.testing.cleanup import cleanUp
-
-class Base(object):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-
-    def _zcmlConfigure(self):
-        import repoze.bfg.includes
-        import zope.configuration.xmlconfig
-        zope.configuration.xmlconfig.file('configure.zcml',
-                                          package=repoze.bfg.includes)
-
-    def _getTemplatePath(self, name):
-        import os
-        here = os.path.abspath(os.path.dirname(__file__))
-        return os.path.join(here, 'fixtures', name)
-
-class GenshiTemplateRendererTests(Base, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
-        return GenshiTemplateRenderer
-
-    def _makeOne(self, *arg, **kw):
-        klass = self._getTargetClass()
-        return klass(*arg, **kw)
-
-    def test_instance_implements_ITemplate(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ITemplateRenderer
-        path = self._getTemplatePath('minimal.genshi')
-        verifyObject(ITemplateRenderer, self._makeOne(path))
-
-    def test_class_implements_ITemplate(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import ITemplateRenderer
-        verifyClass(ITemplateRenderer, self._getTargetClass())
-
-    def test_call(self):
-        self._zcmlConfigure()
-        minimal = self._getTemplatePath('minimal.genshi')
-        instance = self._makeOne(minimal)
-        result = instance()
-        self.failUnless(isinstance(result, str))
-        self.assertEqual(result,
-                         '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
-
-    def test_implementation(self):
-        self._zcmlConfigure()
-        minimal = self._getTemplatePath('minimal.genshi')
-        instance = self._makeOne(minimal)
-        result = instance.implementation()()
-        self.failUnless(isinstance(result, str))
-        self.assertEqual(result,
-                         '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
-
-class RenderTemplateTests(Base, unittest.TestCase):
-    def _callFUT(self, name, **kw):
-        from repoze.bfg.chameleon_genshi import render_template
-        return render_template(name, **kw)
-
-    def test_it(self):
-        minimal = self._getTemplatePath('minimal.genshi')
-        result = self._callFUT(minimal)
-        self.failUnless(isinstance(result, str))
-        self.assertEqual(result,
-                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
-
-class RenderTemplateToResponseTests(Base, unittest.TestCase):
-    def _callFUT(self, name, **kw):
-        from repoze.bfg.chameleon_genshi import render_template_to_response
-        return render_template_to_response(name, **kw)
-
-    def test_it(self):
-        minimal = self._getTemplatePath('minimal.genshi')
-        result = self._callFUT(minimal)
-        from webob import Response
-        self.failUnless(isinstance(result, Response))
-        self.assertEqual(result.app_iter,
-                      ['<div xmlns="http://www.w3.org/1999/xhtml">\n</div>'])
-        self.assertEqual(result.status, '200 OK')
-        self.assertEqual(len(result.headerlist), 2)
-
-    def test_iresponsefactory_override(self):
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        from webob import Response
-        class Response2(Response):
-            pass
-        from repoze.bfg.interfaces import IResponseFactory
-        gsm.registerUtility(Response2, IResponseFactory)
-        minimal = self._getTemplatePath('minimal.genshi')
-        result = self._callFUT(minimal)
-        self.failUnless(isinstance(result, Response2))
-
-class GetRendererTests(Base, unittest.TestCase):
-    def _callFUT(self, name):
-        from repoze.bfg.chameleon_genshi import get_renderer
-        return get_renderer(name)
-
-    def test_nonabs_registered(self):
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.genshi')
-        utility = GenshiTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.genshi')
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
-        utility = GenshiTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result, utility)
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import ITemplateRenderer
-        class Dummy:
-            template = object()
-        gsm = getGlobalSiteManager()
-        utility = Dummy()
-        gsm.registerUtility(utility, ITemplateRenderer, name='foo')
-        result = self._callFUT('foo')
-        self.failUnless(result is utility)
-    
-
-class GetTemplateTests(Base, unittest.TestCase):
-    def _callFUT(self, name):
-        from repoze.bfg.chameleon_genshi import get_template
-        return get_template(name)
-
-    def test_nonabs_registered(self):
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.genshi')
-        utility = GenshiTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
-        
-    def test_nonabs_unregistered(self):
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
-        from repoze.bfg.interfaces import ITemplateRenderer
-        minimal = self._getTemplatePath('minimal.genshi')
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
-        utility = GenshiTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
-        result = self._callFUT(minimal)
-        self.assertEqual(result.filename, minimal)
-        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
-
-    def test_explicit_registration(self):
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import ITemplateRenderer
-        class Dummy:
-            template = object()
-            def implementation(self):
-                return self.template
-        gsm = getGlobalSiteManager()
-        utility = Dummy()
-        gsm.registerUtility(utility, ITemplateRenderer, name='foo')
-        result = self._callFUT('foo')
-        self.failUnless(result is utility.template)
diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py
index 114817994..e0ed74e5f 100644
--- a/repoze/bfg/tests/test_chameleon_zpt.py
+++ b/repoze/bfg/tests/test_chameleon_zpt.py
@@ -45,7 +45,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
         minimal = self._getTemplatePath('minimal.pt')
         instance = self._makeOne(minimal)
         result = instance()
-        self.failUnless(isinstance(result, str))
+        self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
@@ -54,7 +54,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
         minimal = self._getTemplatePath('minimal.pt')
         instance = self._makeOne(minimal)
         result = instance.implementation()()
-        self.failUnless(isinstance(result, str))
+        self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
         
@@ -68,7 +68,7 @@ class RenderTemplateTests(Base, unittest.TestCase):
         self._zcmlConfigure()
         minimal = self._getTemplatePath('minimal.pt')
         result = self._callFUT(minimal)
-        self.failUnless(isinstance(result, str))
+        self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
diff --git a/repoze/bfg/tests/test_template.py b/repoze/bfg/tests/test_template.py
index 8d16972b8..78bd139c5 100644
--- a/repoze/bfg/tests/test_template.py
+++ b/repoze/bfg/tests/test_template.py
@@ -33,7 +33,7 @@ class RenderTemplateTests(Base, unittest.TestCase):
         self._zcmlConfigure()
         minimal = self._getTemplatePath('minimal.pt')
         result = self._callFUT(minimal)
-        self.failUnless(isinstance(result, str))
+        self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
diff --git a/repoze/bfg/tests/test_xslt.py b/repoze/bfg/tests/test_xslt.py
deleted file mode 100644
index eed0fc808..000000000
--- a/repoze/bfg/tests/test_xslt.py
+++ /dev/null
@@ -1,221 +0,0 @@
-import unittest
-from zope.testing.cleanup import cleanUp
-
-class Base(object):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-
-    def _zcmlConfigure(self):
-        import repoze.bfg.includes
-        import zope.configuration.xmlconfig
-        zope.configuration.xmlconfig.file('configure.zcml',
-                                          package=repoze.bfg.includes)
-
-    def _getTemplatePath(self, name):
-        import os
-        here = os.path.abspath(os.path.dirname(__file__))
-        return os.path.join(here, 'fixtures', name)
-        
-class XSLTemplateRendererTests(Base, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        return XSLTemplateRenderer
-
-    def _makeOne(self, *arg, **kw):
-        klass = self._getTargetClass()
-        return klass(*arg, **kw)
-
-    def test_instance_implements_INodeTemplate(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        path = self._getTemplatePath('minimal.xsl')
-        verifyObject(INodeTemplateRenderer, self._makeOne(path))
-
-    def test_class_implements_INodeTemplate(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        verifyClass(INodeTemplateRenderer, self._getTargetClass())
-
-    def test_call(self):
-        self._zcmlConfigure()
-        minimal = self._getTemplatePath('minimal.xsl')
-        instance = self._makeOne(minimal)
-        from lxml import etree
-        info = etree.Element("info")
-        result = instance(node=info)
-        self.failUnless(isinstance(result, str))
-        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
-        self.assertEqual(result, resultstr)
-
-class GetTransformTests(Base, unittest.TestCase):
-    def _callFUT(self, path, node):
-        from repoze.bfg.xslt import get_transform
-        return get_transform(path, node)
-
-    def test_nonabs_registered(self):
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        renderer = {}
-        gsm = getGlobalSiteManager()
-        minimal = self._getTemplatePath('minimal.xsl')
-        gsm.registerUtility(renderer, INodeTemplateRenderer, name=minimal)
-        result = self._callFUT('fixtures/minimal.xsl', None)
-        self.failUnless(result is renderer)
-        
-    def test_abs_registered(self):
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        renderer = {}
-        gsm = getGlobalSiteManager()
-        minimal = self._getTemplatePath('minimal.xsl')
-        gsm.registerUtility(renderer, INodeTemplateRenderer, name=minimal)
-        result = self._callFUT(minimal, None)
-        self.failUnless(result is renderer)
-
-    def test_unregistered(self):
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), None)
-        gsm = getGlobalSiteManager()
-        result = self._callFUT(minimal, None)
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal).path,
-                         minimal)
-
-    def test_unregistered_missing(self):
-        from zope.component import getGlobalSiteManager
-        minimal = self._getTemplatePath('notthere.xsl')
-        gsm = getGlobalSiteManager()
-        self.assertRaises(ValueError, self._callFUT, minimal, None)
-
-class RenderTransformToResponseTests(Base, unittest.TestCase):
-    def _callFUT(self, minimal, node):
-        from repoze.bfg.xslt import render_transform_to_response
-        return render_transform_to_response(minimal, node=node)
-
-    def test_nonabs_unregistered(self):
-        self._zcmlConfigure()
-        from zope.component import queryUtility
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), None)
-        from lxml import etree
-        info = etree.Element("info")
-        result = self._callFUT(minimal, node=info)
-        from webob import Response
-        self.failUnless(isinstance(result, Response))
-        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
-        self.assertEqual(result.app_iter, [resultstr])
-        self.assertEqual(result.status, '200 OK')
-        self.assertEqual(len(result.headerlist), 2)
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        self.failUnless(isinstance(queryUtility(INodeTemplateRenderer, minimal),
-                                   XSLTemplateRenderer))
-
-    def test_nonabs_registered(self):
-        self._zcmlConfigure()
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        utility = XSLTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, INodeTemplateRenderer, name=minimal)
-        from lxml import etree
-        info = etree.Element("info")
-        result = self._callFUT(minimal, node=info)
-        from webob import Response
-        self.failUnless(isinstance(result, Response))
-        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
-        self.assertEqual(result.app_iter, [resultstr])
-        self.assertEqual(result.status, '200 OK')
-        self.assertEqual(len(result.headerlist), 2)
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), utility)
-
-    def test_alternate_iresponse_factory(self):
-        self._zcmlConfigure()
-        from repoze.bfg.interfaces import IResponseFactory
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        from webob import Response
-        class Response2(Response):
-            pass
-        gsm.registerUtility(Response2, IResponseFactory)
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        utility = XSLTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, INodeTemplateRenderer, name=minimal)
-        from lxml import etree
-        info = etree.Element("info")
-        result = self._callFUT(minimal, node=info)
-        self.failUnless(isinstance(result, Response2))
-
-
-class RenderTransformTests(Base, unittest.TestCase):
-    def _callFUT(self, path, node):
-        from repoze.bfg.xslt import render_transform
-        return render_transform(path, node=node)
-
-    def test_nonabs_unregistered(self):
-        self._zcmlConfigure()
-        from zope.component import queryUtility
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), None)
-        from lxml import etree
-        info = etree.Element("info")
-        result = self._callFUT(minimal, node=info)
-        self.failUnless(isinstance(result, str))
-        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
-        self.assertEqual(result, resultstr)
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        self.failUnless(isinstance(queryUtility(INodeTemplateRenderer, minimal),
-                                   XSLTemplateRenderer))
-
-    def test_nonabs_registered(self):
-        self._zcmlConfigure()
-        from zope.component import getGlobalSiteManager
-        from zope.component import queryUtility
-        from repoze.bfg.xslt import XSLTemplateRenderer
-        from repoze.bfg.interfaces import INodeTemplateRenderer
-        minimal = self._getTemplatePath('minimal.xsl')
-        utility = XSLTemplateRenderer(minimal)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, INodeTemplateRenderer, name=minimal)
-        from lxml import etree
-        info = etree.Element("info")
-        result = self._callFUT(minimal, node=info)
-        self.failUnless(isinstance(result, str))
-        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
-        self.assertEqual(result, resultstr)
-        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), utility)
-
-class TestGetProcessor(Base, unittest.TestCase):
-    def _callFUT(self, fn, auto_reload=False):
-        from repoze.bfg.xslt import get_processor
-        return get_processor(fn, auto_reload)
-
-    def test_no_processors(self):
-        from lxml.etree import XSLT
-        from repoze.bfg.xslt import xslt_pool
-        del xslt_pool.processors
-        path = self._getTemplatePath('minimal.xsl')
-        result = self._callFUT(path)
-        self.failUnless(isinstance(result, XSLT))
-        
-    def test_empty_processors(self):
-        from lxml.etree import XSLT
-        from repoze.bfg.xslt import xslt_pool
-        xslt_pool.processors = {}
-        path = self._getTemplatePath('minimal.xsl')
-        result = self._callFUT(path)
-        self.failUnless(isinstance(result, XSLT))
-    
diff --git a/repoze/bfg/xslt.py b/repoze/bfg/xslt.py
deleted file mode 100644
index 7dae7ca8e..000000000
--- a/repoze/bfg/xslt.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import os
-
-from webob import Response
-
-from zope.component import queryUtility
-from zope.component import getSiteManager
-from zope.deprecation import deprecated
-
-from zope.interface import classProvides
-from zope.interface import implements
-
-from repoze.bfg.path import caller_path
-
-from repoze.bfg.interfaces import INodeTemplateRenderer
-from repoze.bfg.interfaces import IResponseFactory
-from repoze.bfg.interfaces import ITemplateRendererFactory
-
-def get_transform(path, node):
-    """ Return a callable transform object.  When called, the
-    transform will return a string.  The ``path`` argument should be a
-    package-relative path (also may be absolute) to an XSLT file.
-    When called, the transform will use the kwargs in ``*kw`` as top
-    level names and the lxml node at ``node``."""
-    # Render using XSLT
-    path = caller_path(path)
-
-    renderer = queryUtility(INodeTemplateRenderer, path)
-    if renderer is None:
-        if not os.path.exists(path):
-            raise ValueError('Missing template file: %s' % path)
-        renderer = XSLTemplateRenderer(path)
-        sm = getSiteManager()
-        sm.registerUtility(renderer, INodeTemplateRenderer, name=path)
-    return renderer
-
-def render_transform(path, node, **kw):
-    """ Render a XSL template at the package-relative path (may also
-    be absolute) using the kwargs in ``*kw`` as top-level names and
-    the lxml node at ``node`` and return a string."""
-    path = caller_path(path)
-    template = get_transform(path, node)
-    return template(node, **kw)
-
-def render_transform_to_response(path, node, **kw):
-    """ Render a XSL template at the package-relative path (may also
-    be absolute) using the kwargs in ``*kw`` as top-level names and
-    the lxml node at ``node`` and return a Response object."""
-    path = caller_path(path)
-    result = render_transform(path, node, **kw)
-    response_factory = queryUtility(IResponseFactory, default=Response)
-    return response_factory(result)
-
-class XSLTemplateRenderer(object):
-    classProvides(ITemplateRendererFactory)
-    implements(INodeTemplateRenderer)
-
-    def __init__(self, path, auto_reload=False):
-        self.path = path
-        self.auto_reload = auto_reload
-
-    def __call__(self, node, **kw):
-        processor = get_processor(self.path, self.auto_reload)
-        result = str(processor(node, **kw))
-        return result
-
-XSLTemplateFactory = XSLTemplateRenderer
-deprecated('ZPTTemplateFactory',
-           ('repoze.bfg.xslt.XSLTemplateFactory should now be '
-            'imported as repoze.bfg.xslt.XSLTTemplateRenderer'))
-
-
-# Manage XSLT processors on a per-thread basis
-import threading
-from lxml import etree
-xslt_pool = threading.local()
-def get_processor(xslt_fn, auto_reload=False):
-    if not auto_reload:
-        try:
-            return xslt_pool.processors[xslt_fn]
-        except AttributeError:
-            xslt_pool.processors = {}
-        except KeyError:
-            pass
-
-    # Make a processor and add it to the pool
-    source = etree.ElementTree(file=xslt_fn)
-    proc = etree.XSLT(source)
-    xslt_pool.processors[xslt_fn] = proc
-    return proc