- The concept of "view factories" was removed in favor of always

    calling a view, which is a callable that returns a response
    directly (as opposed to returning a view).  As a result, the
    ``factory`` attribute in the bfg:view ZCML statement has been
    renamed to ``view``.  Various interface names were changed also.

  - ``render_template`` and ``render_transform`` no longer return a
    Response object.  Instead, these return strings.  The old behavior
    can be obtained by using ``render_template_to_response`` and
    ``render_transform_to_response``.

9 files changed, 188 insertions, 316 deletions

diff --git a/repoze/bfg/tests/fixtureapp/configure.zcml b/repoze/bfg/tests/fixtureapp/configure.zcml
index f08cd58ad..265d69511 100644
--- a/repoze/bfg/tests/fixtureapp/configure.zcml
+++ b/repoze/bfg/tests/fixtureapp/configure.zcml
@@ -6,7 +6,7 @@
 
   <bfg:view
       for=".models.IFixture"
-      factory=".views.FixtureView"
+      view=".views.fixture_view"
       permission="repoze.view"
       />
 
diff --git a/repoze/bfg/tests/fixtureapp/views.py b/repoze/bfg/tests/fixtureapp/views.py
index b9b9fc7d9..2babbc59c 100644
--- a/repoze/bfg/tests/fixtureapp/views.py
+++ b/repoze/bfg/tests/fixtureapp/views.py
@@ -1,8 +1,3 @@
-class FixtureView(object):
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
+def fixture_view(context, request):
+    return None
 
-    def __call__(self):
-        pass
-    
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index 148b72427..4b1e914b7 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -12,14 +12,14 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
     def _registerTraverserFactory(self, app, name, *for_):
         import zope.component
         gsm = zope.component.getGlobalSiteManager()
-        from repoze.bfg.interfaces import IPublishTraverserFactory
-        gsm.registerAdapter(app, for_, IPublishTraverserFactory, name)
+        from repoze.bfg.interfaces import ITraverserFactory
+        gsm.registerAdapter(app, for_, ITraverserFactory, name)
 
-    def _registerViewFactory(self, app, name, *for_):
+    def _registerView(self, app, name, *for_):
         import zope.component
         gsm = zope.component.getGlobalSiteManager()
-        from repoze.bfg.interfaces import IViewFactory
-        gsm.registerAdapter(app, for_, IViewFactory, name)
+        from repoze.bfg.interfaces import IView
+        gsm.registerAdapter(app, for_, IView, name)
 
     def _registerPermission(self, permission, name, *for_):
         import zope.component
@@ -27,12 +27,6 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         from repoze.bfg.interfaces import IViewPermission
         gsm.registerAdapter(permission, for_, IViewPermission, name)
 
-    def _registerWSGIFactory(self, app, name, *for_):
-        import zope.component
-        gsm = zope.component.getGlobalSiteManager()
-        from repoze.bfg.interfaces import IWSGIApplicationFactory
-        gsm.registerAdapter(app, for_, IWSGIApplicationFactory, name)
-
     def _registerSecurityPolicy(self, secpol):
         import zope.component
         gsm = zope.component.getGlobalSiteManager()
@@ -77,42 +71,40 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         context = DummyContext()
         traversalfactory = make_traversal_factory(context, '', [])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        response.app_iter = ['Hello world']
+        view = make_view(response)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', None, None)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', None, None)
         router = self._makeOne(rootpolicy, None)
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
         self.assertEqual(start_response.headers, ())
         self.assertEqual(start_response.status, '200 OK')
-        request = environ['request']
-        self.assertEqual(environ['request'].subpath, [])
-        self.assertEqual(environ['view'].context, context)
+        self.assertEqual(environ['webob.adhoc_attrs']['view_name'], '')
+        self.assertEqual(environ['webob.adhoc_attrs']['subpath'], [])
+        self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
 
     def test_call_view_registered_nonspecific_nondefault_path_and_subpath(self):
         rootpolicy = make_rootpolicy(None)
         context = DummyContext()
         traversalfactory = make_traversal_factory(context, 'foo', ['bar'])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        response.app_iter = ['Hello world']
+        view = make_view(response)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, 'foo', None, None)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, 'foo', None, None)
         router = self._makeOne(rootpolicy, None)
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
         self.assertEqual(start_response.headers, ())
         self.assertEqual(start_response.status, '200 OK')
-        request = environ['request']
-        self.assertEqual(environ['request'].subpath, ['bar'])
-        self.assertEqual(environ['view'].context, context)
+        self.assertEqual(environ['webob.adhoc_attrs']['view_name'], 'foo')
+        self.assertEqual(environ['webob.adhoc_attrs']['subpath'], ['bar'])
+        self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
 
     def test_call_view_registered_specific_success(self):
         rootpolicy = make_rootpolicy(None)
@@ -125,21 +117,20 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         directlyProvides(context, IContext)
         traversalfactory = make_traversal_factory(context, '', [])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        response.app_iter = ['Hello world']
+        view = make_view(response)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', IContext, IRequest)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', IContext, IRequest)
         router = self._makeOne(rootpolicy, None)
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
         self.assertEqual(start_response.headers, ())
         self.assertEqual(start_response.status, '200 OK')
-        request = environ['request']
-        self.assertEqual(environ['request'].subpath, [])
-        self.assertEqual(environ['view'].context, context)
+        self.assertEqual(environ['webob.adhoc_attrs']['view_name'], '')
+        self.assertEqual(environ['webob.adhoc_attrs']['subpath'], [])
+        self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
 
     def test_call_view_registered_specific_fail(self):
         rootpolicy = make_rootpolicy(None)
@@ -154,18 +145,16 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         directlyProvides(context, INotContext)
         traversalfactory = make_traversal_factory(context, '', [''])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        view = make_view(response)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', IContext, IRequest)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', IContext, IRequest)
         app_context = make_appcontext()
         router = self._makeOne(rootpolicy, None)
         start_response = DummyStartResponse()
         result = router(environ, start_response)
-        self.failUnless('404' in result[0])
         self.assertEqual(start_response.status, '404 Not Found')
+        self.failUnless('404' in result[0])
 
     def test_call_view_registered_security_policy_permission_none(self):
         rootpolicy = make_rootpolicy(None)
@@ -178,12 +167,10 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         directlyProvides(context, IContext)
         traversalfactory = make_traversal_factory(context, '', [''])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        view = make_view(response)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', IContext, IRequest)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', IContext, IRequest)
         secpol = DummySecurityPolicy()
         self._registerSecurityPolicy(secpol)
         app_context = make_appcontext()
@@ -203,14 +190,12 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         directlyProvides(context, IContext)
         traversalfactory = make_traversal_factory(context, '', [''])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        view = make_view(response)
         secpol = DummySecurityPolicy()
         permissionfactory = make_permission_factory(True)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', IContext, IRequest)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', IContext, IRequest)
         self._registerSecurityPolicy(secpol)
         self._registerPermission(permissionfactory, '', IContext, IRequest)
         app_context = make_appcontext()
@@ -220,7 +205,7 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         self.assertEqual(start_response.status, '200 OK')
         self.assertEqual(permissionfactory.checked_with, secpol)
 
-    def test_call_view_registered_security_policy_permission_failss(self):
+    def test_call_view_registered_security_policy_permission_fails(self):
         rootpolicy = make_rootpolicy(None)
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -231,14 +216,12 @@ class RouterTests(unittest.TestCase, PlacelessSetup):
         directlyProvides(context, IContext)
         traversalfactory = make_traversal_factory(context, '', [''])
         response = DummyResponse()
-        viewfactory = make_view_factory(response)
-        wsgifactory = make_wsgi_factory('200 OK', (), ['Hello world'])
+        view = make_view(response)
         secpol = DummySecurityPolicy()
         permissionfactory = make_permission_factory(False)
         environ = self._makeEnviron()
         self._registerTraverserFactory(traversalfactory, '', None, None)
-        self._registerViewFactory(viewfactory, '', IContext, IRequest)
-        self._registerWSGIFactory(wsgifactory, '', None, None, None)
+        self._registerView(view, '', IContext, IRequest)
         self._registerSecurityPolicy(secpol)
         self._registerPermission(permissionfactory, '', IContext, IRequest)
         app_context = make_appcontext()
@@ -287,15 +270,10 @@ def make_wsgi_factory(status, headers, app_iter):
 
     return DummyWSGIApplicationFactory
 
-def make_view_factory(response):
-    class DummyViewFactory:
-        def __init__(self, context, request):
-            self.context = context
-            self.request = request
-
-        def __call__(self):
-            return response
-    return DummyViewFactory
+def make_view(response):
+    def view(context, request):
+        return response
+    return view
 
 def make_traversal_factory(context, name, subpath):
     class DummyTraversalFactory:
diff --git a/repoze/bfg/tests/test_template.py b/repoze/bfg/tests/test_template.py
index 96129504d..1a5fcf1f4 100644
--- a/repoze/bfg/tests/test_template.py
+++ b/repoze/bfg/tests/test_template.py
@@ -34,32 +34,24 @@ class Z3CPTTemplateFactoryTests(unittest.TestCase, Base):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
 
-    def test_instance_conforms_to_IView(self):
+    def test_instance_implements_ITemplate(self):
         from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import ITemplate
         path = self._getTemplatePath('minimal.pt')
-        verifyObject(IView, self._makeOne(path))
+        verifyObject(ITemplate, self._makeOne(path))
 
-    def test_class_conforms_to_IView(self):
+    def test_class_implements_ITemplate(self):
         from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import IView
-        verifyClass(IView, self._getTargetClass())
-
-    def test_class_conforms_to_ITemplateFactory(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ITemplateFactory
-        verifyObject(ITemplateFactory, self._getTargetClass())
+        from repoze.bfg.interfaces import ITemplate
+        verifyClass(ITemplate, self._getTargetClass())
 
     def test_call(self):
         self._zcmlConfigure()
         minimal = self._getTemplatePath('minimal.pt')
         instance = self._makeOne(minimal)
         result = instance()
-        from webob import Response
-        self.failUnless(isinstance(result, Response))
-        self.assertEqual(result.app_iter, ['<div>\n</div>'])
-        self.assertEqual(result.status, '200 OK')
-        self.assertEqual(len(result.headerlist), 2)
+        self.failUnless(isinstance(result, str))
+        self.assertEqual(result, '<div>\n</div>')
 
 class RenderTemplateTests(unittest.TestCase, Base):
     def setUp(self):
@@ -75,9 +67,50 @@ class RenderTemplateTests(unittest.TestCase, Base):
     def test_nonabs_unregistered(self):
         self._zcmlConfigure()
         from zope.component import queryUtility
-        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import ITemplate
+        minimal = self._getTemplatePath('minimal.pt')
+        self.assertEqual(queryUtility(ITemplate, minimal), None)
+        render = self._getFUT()
+        result = render(minimal)
+        self.failUnless(isinstance(result, str))
+        self.assertEqual(result, '<div>\n</div>')
+        from repoze.bfg.template import Z3CPTTemplateFactory
+        self.failUnless(isinstance(queryUtility(ITemplate, minimal),
+                                   Z3CPTTemplateFactory))
+
+    def test_nonabs_registered(self):
+        self._zcmlConfigure()
+        from zope.component import getGlobalSiteManager
+        from zope.component import queryUtility
+        from repoze.bfg.template import Z3CPTTemplateFactory
+        from repoze.bfg.interfaces import ITemplate
+        minimal = self._getTemplatePath('minimal.pt')
+        utility = Z3CPTTemplateFactory(minimal)
+        gsm = getGlobalSiteManager()
+        gsm.registerUtility(utility, ITemplate, name=minimal)
+        render = self._getFUT()
+        result = render(minimal)
+        self.failUnless(isinstance(result, str))
+        self.assertEqual(result, '<div>\n</div>')
+        self.assertEqual(queryUtility(ITemplate, minimal), utility)
+
+class RenderTemplateToResponseTests(unittest.TestCase, Base):
+    def setUp(self):
+        Base.setUp(self)
+
+    def tearDown(self):
+        Base.tearDown(self)
+
+    def _getFUT(self):
+        from repoze.bfg.template import render_template_to_response
+        return render_template_to_response
+
+    def test_nonabs_unregistered(self):
+        self._zcmlConfigure()
+        from zope.component import queryUtility
+        from repoze.bfg.interfaces import ITemplate
         minimal = self._getTemplatePath('minimal.pt')
-        self.assertEqual(queryUtility(IView, minimal), None)
+        self.assertEqual(queryUtility(ITemplate, minimal), None)
         render = self._getFUT()
         result = render(minimal)
         from webob import Response
@@ -86,7 +119,7 @@ class RenderTemplateTests(unittest.TestCase, Base):
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
         from repoze.bfg.template import Z3CPTTemplateFactory
-        self.failUnless(isinstance(queryUtility(IView, minimal),
+        self.failUnless(isinstance(queryUtility(ITemplate, minimal),
                                    Z3CPTTemplateFactory))
 
     def test_nonabs_registered(self):
@@ -94,11 +127,11 @@ class RenderTemplateTests(unittest.TestCase, Base):
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
         from repoze.bfg.template import Z3CPTTemplateFactory
-        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import ITemplate
         minimal = self._getTemplatePath('minimal.pt')
         utility = Z3CPTTemplateFactory(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, IView, name=minimal)
+        gsm.registerUtility(utility, ITemplate, name=minimal)
         render = self._getFUT()
         result = render(minimal)
         from webob import Response
@@ -106,9 +139,6 @@ class RenderTemplateTests(unittest.TestCase, Base):
         self.assertEqual(result.app_iter, ['<div>\n</div>'])
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
-        self.assertEqual(queryUtility(IView, minimal), utility)
+        self.assertEqual(queryUtility(ITemplate, minimal), utility)
         
-class DummyView:
-    context = 'context'
-    request = 'request'
         
diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py
index 528ca0bf4..61dff6d88 100644
--- a/repoze/bfg/tests/test_traversal.py
+++ b/repoze/bfg/tests/test_traversal.py
@@ -36,8 +36,8 @@ class NaivePublishTraverserTests(unittest.TestCase, PlacelessSetup):
         PlacelessSetup.tearDown(self)
         
     def _getTargetClass(self):
-        from repoze.bfg.traversal import NaivePublishTraverser
-        return NaivePublishTraverser
+        from repoze.bfg.traversal import NaiveTraverser
+        return NaiveTraverser
 
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
@@ -45,15 +45,15 @@ class NaivePublishTraverserTests(unittest.TestCase, PlacelessSetup):
 
     def test_class_conforms_to_IPublishTraverser(self):
         from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import IPublishTraverser
-        verifyClass(IPublishTraverser, self._getTargetClass())
+        from repoze.bfg.interfaces import ITraverser
+        verifyClass(ITraverser, self._getTargetClass())
 
     def test_instance_conforms_to_IPublishTraverser(self):
         from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import IPublishTraverser
+        from repoze.bfg.interfaces import ITraverser
         context = DummyContext()
         request = DummyRequest()
-        verifyObject(IPublishTraverser, self._makeOne(context, request))
+        verifyObject(ITraverser, self._makeOne(context, request))
 
     def test_call_pathel_with_no_getitem(self):
         request = DummyRequest()
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
deleted file mode 100644
index a78fe514a..000000000
--- a/repoze/bfg/tests/test_view.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import unittest
-
-from zope.component.testing import PlacelessSetup
-
-class Base(PlacelessSetup):
-    def setUp(self):
-        PlacelessSetup.setUp(self)
-
-    def tearDown(self):
-        PlacelessSetup.tearDown(self)
-
-    def _zcmlConfigure(self):
-        import repoze.bfg
-        import zope.configuration.xmlconfig
-        zope.configuration.xmlconfig.file('configure.zcml', package=repoze.bfg)
-
-    def _getTemplatePath(self, name):
-        import os
-        here = os.path.abspath(os.path.dirname(__file__))
-        return os.path.join(here, 'fixtures', name)
-
-class ViewFactoryTests(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.view import ViewFactory
-        return ViewFactory
-
-    def _makeOne(self, *arg, **kw):
-        klass = self._getTargetClass()
-        return klass(*arg, **kw)
-
-    def test_call(self):
-        view = self._makeOne(None, None)
-        self.assertRaises(NotImplementedError, view)
-
diff --git a/repoze/bfg/tests/test_wsgiadapter.py b/repoze/bfg/tests/test_wsgiadapter.py
deleted file mode 100644
index 217d43427..000000000
--- a/repoze/bfg/tests/test_wsgiadapter.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import unittest
-
-from zope.component.testing import PlacelessSetup
-
-class NaiveWSGIAdapterTests(unittest.TestCase, PlacelessSetup):
-    def setUp(self):
-        PlacelessSetup.setUp(self)
-
-    def tearDown(self):
-        PlacelessSetup.tearDown(self)
-
-    def _getTargetClass(self):
-        from repoze.bfg.wsgiadapter import NaiveWSGIViewAdapter
-        return NaiveWSGIViewAdapter
-
-    def _makeOne(self, *arg, **kw):
-        klass = self._getTargetClass()
-        return klass(*arg, **kw)
-
-    def test_view_takes_no_args(self):
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        def view():
-            return response
-        request = DummyRequest()
-        context = DummyContext()
-        adapter = self._makeOne(context, request, view)
-        environ = {}
-        start_response = DummyStartResponse()
-        result = adapter(environ, start_response)
-        self.assertEqual(result, ['Hello world'])
-        self.assertEqual(start_response.headers, ())
-        self.assertEqual(start_response.status, '200 OK')
-
-    def test_view_takes_pep_333_args(self):
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        def view(environ, start_response):
-            response.environ = environ
-            response.start_response = start_response
-            return response
-        request = DummyRequest()
-        context = DummyContext()
-        adapter = self._makeOne(context, request, view)
-        environ = {}
-        start_response = DummyStartResponse()
-        result = adapter(environ, start_response)
-        self.assertEqual(result, ['Hello world'])
-        self.assertEqual(start_response.headers, ())
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(response.environ, environ)
-        self.assertEqual(response.start_response, start_response)
-
-    def test_view_takes_zopey_args(self):
-        request = DummyRequest()
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        def view(request):
-            response.request = request
-            return response
-        context = DummyContext()
-        adapter = self._makeOne(context, request, view)
-        environ = {}
-        start_response = DummyStartResponse()
-        result = adapter(environ, start_response)
-        self.assertEqual(result, ['Hello world'])
-        self.assertEqual(start_response.headers, ())
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(response.request, request)
-
-    def test_view_is_response(self):
-        request = DummyRequest()
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        context = DummyContext()
-        adapter = self._makeOne(context, request, response)
-        environ = {}
-        start_response = DummyStartResponse()
-        result = adapter(environ, start_response)
-        self.assertEqual(result, ['Hello world'])
-        self.assertEqual(start_response.headers, ())
-        self.assertEqual(start_response.status, '200 OK')
-
-    def test_view_returns_nonresponse(self):
-        request = DummyRequest()
-        def view(request):
-            return None
-        context = DummyContext()
-        adapter = self._makeOne(context, request, view)
-        environ = {}
-        start_response = DummyStartResponse()
-        self.assertRaises(ValueError, adapter, environ, start_response)
-
-
-class DummyContext:
-    pass
-
-class DummyRequest:
-    pass
-
-class DummyResponse:
-    status = '200 OK'
-    headerlist = ()
-    app_iter = ()
-    
-class DummyStartResponse:
-    status = None
-    headers = None
-    def __call__(self, status, headers):
-        self.status = status
-        self.headers = headers
-        
-
diff --git a/repoze/bfg/tests/test_xslt.py b/repoze/bfg/tests/test_xslt.py
index ebf0e625d..01e5befba 100644
--- a/repoze/bfg/tests/test_xslt.py
+++ b/repoze/bfg/tests/test_xslt.py
@@ -34,21 +34,16 @@ class XSLTemplateFactoryTests(unittest.TestCase, Base):
         klass = self._getTargetClass()
         return klass(*arg, **kw)
 
-    def test_instance_conforms_to_INodeView(self):
+    def test_instance_implements_INodeTemplate(self):
         from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import INodeView
+        from repoze.bfg.interfaces import INodeTemplate
         path = self._getTemplatePath('minimal.xsl')
-        verifyObject(INodeView, self._makeOne(path))
+        verifyObject(INodeTemplate, self._makeOne(path))
 
-    def test_class_conforms_to_INodeView(self):
+    def test_class_implements_INodeTemplate(self):
         from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import INodeView
-        verifyClass(INodeView, self._getTargetClass())
-
-    def test_class_conforms_to_ITemplateFactory(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ITemplateFactory
-        verifyObject(ITemplateFactory, self._getTargetClass())
+        from repoze.bfg.interfaces import INodeTemplate
+        verifyClass(INodeTemplate, self._getTargetClass())
 
     def test_call(self):
         self._zcmlConfigure()
@@ -57,14 +52,11 @@ class XSLTemplateFactoryTests(unittest.TestCase, Base):
         from lxml import etree
         info = etree.Element("info")
         result = instance(node=info)
-        from webob import Response
-        self.failUnless(isinstance(result, Response))
+        self.failUnless(isinstance(result, str))
         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(result, resultstr)
 
-class RenderTemplateTests(unittest.TestCase, Base):
+class RenderTransformToResponseTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
 
@@ -72,15 +64,15 @@ class RenderTemplateTests(unittest.TestCase, Base):
         Base.tearDown(self)
 
     def _getFUT(self):
-        from repoze.bfg.template import render_transform
-        return render_transform
+        from repoze.bfg.template import render_transform_to_response
+        return render_transform_to_response
 
     def test_nonabs_unregistered(self):
         self._zcmlConfigure()
         from zope.component import queryUtility
-        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import INodeTemplate
         minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(IView, minimal), None)
+        self.assertEqual(queryUtility(INodeTemplate, minimal), None)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -92,7 +84,7 @@ class RenderTemplateTests(unittest.TestCase, Base):
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
         from repoze.bfg.template import XSLTemplateFactory
-        self.failUnless(isinstance(queryUtility(IView, minimal),
+        self.failUnless(isinstance(queryUtility(INodeTemplate, minimal),
                                    XSLTemplateFactory))
 
     def test_nonabs_registered(self):
@@ -100,11 +92,11 @@ class RenderTemplateTests(unittest.TestCase, Base):
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
         from repoze.bfg.template import XSLTemplateFactory
-        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import INodeTemplate
         minimal = self._getTemplatePath('minimal.xsl')
         utility = XSLTemplateFactory(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, IView, name=minimal)
+        gsm.registerUtility(utility, INodeTemplate, name=minimal)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -115,9 +107,52 @@ class RenderTemplateTests(unittest.TestCase, Base):
         self.assertEqual(result.app_iter, [resultstr])
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
-        self.assertEqual(queryUtility(IView, minimal), utility)
-        
-class DummyView:
-    context = 'context'
-    request = 'request'
-        
+        self.assertEqual(queryUtility(INodeTemplate, minimal), utility)
+
+class RenderTransformTests(unittest.TestCase, Base):
+    def setUp(self):
+        Base.setUp(self)
+
+    def tearDown(self):
+        Base.tearDown(self)
+
+    def _getFUT(self):
+        from repoze.bfg.template import render_transform
+        return render_transform
+
+    def test_nonabs_unregistered(self):
+        self._zcmlConfigure()
+        from zope.component import queryUtility
+        from repoze.bfg.interfaces import INodeTemplate
+        minimal = self._getTemplatePath('minimal.xsl')
+        self.assertEqual(queryUtility(INodeTemplate, minimal), None)
+        render = self._getFUT()
+        from lxml import etree
+        info = etree.Element("info")
+        result = render(minimal, node=info)
+        self.failUnless(isinstance(result, str))
+        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
+        self.assertEqual(result, resultstr)
+        from repoze.bfg.template import XSLTemplateFactory
+        self.failUnless(isinstance(queryUtility(INodeTemplate, minimal),
+                                   XSLTemplateFactory))
+
+    def test_nonabs_registered(self):
+        self._zcmlConfigure()
+        from zope.component import getGlobalSiteManager
+        from zope.component import queryUtility
+        from repoze.bfg.template import XSLTemplateFactory
+        from repoze.bfg.interfaces import INodeTemplate
+        minimal = self._getTemplatePath('minimal.xsl')
+        utility = XSLTemplateFactory(minimal)
+        gsm = getGlobalSiteManager()
+        gsm.registerUtility(utility, INodeTemplate, name=minimal)
+        render = self._getFUT()
+        from lxml import etree
+        info = etree.Element("info")
+        result = render(minimal, node=info)
+        self.failUnless(isinstance(result, str))
+        resultstr = """<?xml version="1.0"?>\n<div/>\n"""
+        self.assertEqual(result, resultstr)
+        self.assertEqual(queryUtility(INodeTemplate, minimal), utility)
+
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index a2602b9c1..f8ef78ff8 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -33,9 +33,9 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
             pass
         f(context, 'repoze.view', IFoo, template='minimal.pt')
         actions = context.actions
+        from repoze.bfg.interfaces import ITemplate
         from repoze.bfg.interfaces import IView
         from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IViewFactory
         from repoze.bfg.interfaces import IViewPermission
         from repoze.bfg.security import ViewPermissionFactory
         from zope.component.zcml import handler
@@ -43,14 +43,15 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
 
         self.assertEqual(len(actions), 4)
 
-        regutil_discriminator = ('utility', IView, context.path('minimal.pt'))
+        regutil_discriminator = ('utility', ITemplate,
+                                 context.path('minimal.pt'))
         regutil = actions[0]
         self.assertEqual(regutil['discriminator'], regutil_discriminator)
         self.assertEqual(regutil['callable'], handler)
         self.assertEqual(regutil['args'][0], 'registerUtility')
         self.assertEqual(regutil['args'][1].template.filename,
                          context.path('minimal.pt'))
-        self.assertEqual(regutil['args'][2], IView)
+        self.assertEqual(regutil['args'][2], ITemplate)
         self.assertEqual(regutil['args'][3], context.path('minimal.pt'))
 
         provide = actions[1]
@@ -73,14 +74,14 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
         self.assertEqual(permission['args'][5], None)
 
         regadapt = actions[3]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IViewFactory)
+        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
         self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
         self.assertEqual(regadapt['callable'], handler)
         self.assertEqual(regadapt['args'][0], 'registerAdapter')
         self.assertEqual(regadapt['args'][1].template,
                          context.path('minimal.pt'))
         self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IViewFactory)
+        self.assertEqual(regadapt['args'][3], IView)
         self.assertEqual(regadapt['args'][4], '')
         self.assertEqual(regadapt['args'][5], None)
 
@@ -89,10 +90,12 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
         context = DummyContext()
         class IFoo:
             pass
-        f(context, 'repoze.view', IFoo, factory=Dummy)
+        def view(context, request):
+            pass
+        f(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
         from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IViewFactory
+        from repoze.bfg.interfaces import IView
         from repoze.bfg.interfaces import IViewPermission
         from repoze.bfg.security import ViewPermissionFactory
         from zope.component.zcml import handler
@@ -120,13 +123,13 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
         self.assertEqual(permission['args'][5], None)
         
         regadapt = actions[2]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IViewFactory)
+        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
         self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
         self.assertEqual(regadapt['callable'], handler)
         self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], Dummy)
+        self.assertEqual(regadapt['args'][1], view)
         self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IViewFactory)
+        self.assertEqual(regadapt['args'][3], IView)
         self.assertEqual(regadapt['args'][4], '')
         self.assertEqual(regadapt['args'][5], None)
 
@@ -135,31 +138,9 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
         context = DummyContext()
         from zope.configuration.exceptions import ConfigurationError
         self.assertRaises(ConfigurationError, f, context, 'repoze.view',
-                          None, factory=object, template='minimal.pt')
-
-class TestTemplateOnlyViewFactory(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.zcml import TemplateOnlyViewFactory
-        return TemplateOnlyViewFactory
+                          None, view=object, template='minimal.pt')
 
-    def _makeOne(self, template):
-        return self._getTargetClass()(template)
-
-    def test_instance_conforms_to_IViewFactory(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import IViewFactory
-        verifyObject(IViewFactory, self._makeOne('a'))
-
-    def test_call(self):
-        context = DummyContext()
-        template = context.path('minimal.pt')
-        factory = self._makeOne(template)
-        view = factory(None, None)
-        from repoze.bfg.zcml import TemplateOnlyView
-        self.failUnless(isinstance(view, TemplateOnlyView))
-        self.assertEqual(view.template, template)
-
-class TemplateOnlyViewTests(unittest.TestCase, PlacelessSetup):
+class TemplateOnlyViewFactoryTests(unittest.TestCase, PlacelessSetup):
     def setUp(self):
         PlacelessSetup.setUp(self)
 
@@ -167,8 +148,8 @@ class TemplateOnlyViewTests(unittest.TestCase, PlacelessSetup):
         PlacelessSetup.tearDown(self)
 
     def _getTargetClass(self):
-        from repoze.bfg.zcml import TemplateOnlyView
-        return TemplateOnlyView
+        from repoze.bfg.zcml import TemplateOnlyViewFactory
+        return TemplateOnlyViewFactory
 
     def _zcmlConfigure(self):
         import repoze.bfg
@@ -186,9 +167,9 @@ class TemplateOnlyViewTests(unittest.TestCase, PlacelessSetup):
 
     def test_call(self):
         self._zcmlConfigure()
-        view = self._makeOne(None, None)
-        view.template = self._getTemplatePath('minimal.pt')
-        result = view(foo='foo')
+        path = self._getTemplatePath('minimal.pt')
+        view = self._makeOne(path)
+        result = view(None, None)
         from webob import Response
         self.failUnless(isinstance(result, Response))
         self.assertEqual(result.app_iter, ['<div>\n</div>'])
@@ -197,8 +178,8 @@ class TemplateOnlyViewTests(unittest.TestCase, PlacelessSetup):
         
     def test_call_no_template(self):
         self._zcmlConfigure()
-        view = self._makeOne(None, None)
-        self.assertRaises(ValueError, view)
+        view = self._makeOne('nosuch')
+        self.assertRaises(ValueError, view, None, None)
 
 class TestSampleApp(unittest.TestCase, PlacelessSetup):
     def setUp(self):