- Class objects may now be used as view callables (both via ZCML and

  via use of the ``bfg_view`` decorator in Python 2.6 as a class
  decorator).  The calling semantics when using a class as a view
  callable is similar to that of using a class as a Zope "browser
  view": the class' ``__init__`` must accept two positional parameters
  (conventionally named ``context``, and ``request``).  The resulting
  instance must be callable (it must have a ``__call__`` method).
  When called, the instance should return a response.  For example::

    from webob import Response

    class MyView(object):
        def __init__(self, context, request):
            self.context = context
            self.request = request

        def __call__(self):
            return Response('hello from %s!' % self.context)

   See the "Views" chapter in the documentation and the
   ``repoze.bfg.view`` API documentation for more information.

4 files changed, 128 insertions, 6 deletions

diff --git a/repoze/bfg/tests/grokkedapp/__init__.py b/repoze/bfg/tests/grokkedapp/__init__.py
index 9d91eb80f..aeedd4dba 100644
--- a/repoze/bfg/tests/grokkedapp/__init__.py
+++ b/repoze/bfg/tests/grokkedapp/__init__.py
@@ -8,4 +8,19 @@ class INothing(Interface):
 def grokked(context, request):
     """ """
     
+class grokked_klass(object):
+    """ """
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
 
+    def __call__(self):
+        """ """
+        
+# in 2.6+ the below can be spelled as a class decorator:
+#
+# @bfg_view(for_=INothing, name='grokked_klass')
+# class grokked_class(object):
+#     ....
+#
+grokked_klass = bfg_view(for_=INothing, name='grokked_klass')(grokked_klass)
diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index 8c088fce0..fdb85b87e 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -1,4 +1,5 @@
 import os
+import sys
 import unittest
 
 from repoze.bfg.push import pushpage
@@ -142,8 +143,8 @@ class TestGrokkedApp(unittest.TestCase):
         cleanUp()
 
     def test_it(self):
+        import inspect
         import repoze.bfg.tests.grokkedapp as package
-        
         from zope.configuration import config
         from zope.configuration import xmlconfig
         context = config.ConfigurationMachine()
@@ -151,7 +152,14 @@ class TestGrokkedApp(unittest.TestCase):
         context.package = package
         xmlconfig.include(context, 'configure.zcml', package)
         actions = context.actions
-        self.failUnless(actions)
+        klassview = actions[-1]
+        self.assertEqual(klassview[0][2], 'grokked_klass')
+        self.assertEqual(klassview[2][1], package.grokked_klass)
+        self.failUnless(inspect.isfunction(package.grokked_klass))
+        self.assertEqual(package.grokked_klass(None, None), None)
+        funcview = actions[-2]
+        self.assertEqual(funcview[0][2], '')
+        self.assertEqual(funcview[2][1], package.grokked)
 
 class DummyContext:
     pass
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index a96051226..08beffeaa 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -446,13 +446,60 @@ class TestBFGViewDecorator(unittest.TestCase):
         self.assertEqual(decorator.for_, None)
         self.assertEqual(decorator.permission, 'foo')
         
-    def test_call(self):
+    def test_call_function(self):
+        from repoze.bfg.interfaces import IRequest
+        from zope.interface import Interface
+        decorator = self._makeOne()
+        def foo():
+            """ docstring """
+        wrapped = decorator(foo)
+        self.failUnless(wrapped is foo)
+        self.assertEqual(wrapped.__is_bfg_view__, True)
+        self.assertEqual(wrapped.__permission__, None)
+        self.assertEqual(wrapped.__for__, Interface)
+        self.assertEqual(wrapped.__request_type__, IRequest)
+
+    def test_call_oldstyle_class(self):
+        import inspect
         from repoze.bfg.interfaces import IRequest
         from zope.interface import Interface
         decorator = self._makeOne()
         class foo:
             """ docstring """
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+            def __call__(self):
+                return self
+        wrapped = decorator(foo)
+        self.failIf(wrapped is foo)
+        self.failUnless(inspect.isfunction(wrapped))
+        self.assertEqual(wrapped.__is_bfg_view__, True)
+        self.assertEqual(wrapped.__permission__, None)
+        self.assertEqual(wrapped.__for__, Interface)
+        self.assertEqual(wrapped.__request_type__, IRequest)
+        self.assertEqual(wrapped.__module__, foo.__module__)
+        self.assertEqual(wrapped.__name__, foo.__name__)
+        self.assertEqual(wrapped.__doc__, foo.__doc__)
+        result = wrapped(None, None)
+        self.assertEqual(result.context, None)
+        self.assertEqual(result.request, None)
+
+    def test_call_newstyle_class(self):
+        import inspect
+        from repoze.bfg.interfaces import IRequest
+        from zope.interface import Interface
+        decorator = self._makeOne()
+        class foo(object):
+            """ docstring """
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+            def __call__(self):
+                return self
         wrapped = decorator(foo)
+        self.failIf(wrapped is foo)
+        self.failUnless(inspect.isfunction(wrapped))
         self.assertEqual(wrapped.__is_bfg_view__, True)
         self.assertEqual(wrapped.__permission__, None)
         self.assertEqual(wrapped.__for__, Interface)
@@ -460,8 +507,9 @@ class TestBFGViewDecorator(unittest.TestCase):
         self.assertEqual(wrapped.__module__, foo.__module__)
         self.assertEqual(wrapped.__name__, foo.__name__)
         self.assertEqual(wrapped.__doc__, foo.__doc__)
-        for k, v in foo.__dict__.items():
-            self.assertEqual(v, wrapped.__dict__[k])
+        result = wrapped(None, None)
+        self.assertEqual(result.context, None)
+        self.assertEqual(result.request, None)
 
 class DummyContext:
     pass
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index c2703f7c1..e44fe1307 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -19,7 +19,7 @@ class TestViewDirective(unittest.TestCase):
         self.assertRaises(ConfigurationError, self._callFUT, context,
                           'repoze.view', None)
 
-    def test_only_view(self):
+    def test_view_as_function(self):
         context = DummyContext()
         class IFoo:
             pass
@@ -58,6 +58,57 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(regadapt['args'][4], '')
         self.assertEqual(regadapt['args'][5], None)
 
+    def test_view_as_oldstyle_class(self):
+        context = DummyContext()
+        class IFoo:
+            pass
+        class view:
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+
+            def __call__(self):
+                return self
+        self._callFUT(context, 'repoze.view', IFoo, view=view)
+        actions = context.actions
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IViewPermission
+        from repoze.bfg.security import ViewPermissionFactory
+        from repoze.bfg.zcml import handler
+
+        self.assertEqual(len(actions), 2)
+
+        permission = actions[0]
+        permission_discriminator = ('permission', IFoo, '', IRequest,
+                                    IViewPermission)
+        self.assertEqual(permission['discriminator'], permission_discriminator)
+        self.assertEqual(permission['callable'], handler)
+        self.assertEqual(permission['args'][0], 'registerAdapter')
+        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
+        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
+        self.assertEqual(permission['args'][2], (IFoo, IRequest))
+        self.assertEqual(permission['args'][3], IViewPermission)
+        self.assertEqual(permission['args'][4], '')
+        self.assertEqual(permission['args'][5], None)
+        
+        regadapt = actions[1]
+        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
+        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
+        self.assertEqual(regadapt['callable'], handler)
+        self.assertEqual(regadapt['args'][0], 'registerAdapter')
+        wrapper = regadapt['args'][1]
+        self.assertEqual(wrapper.__module__, view.__module__)
+        self.assertEqual(wrapper.__name__, view.__name__)
+        self.assertEqual(wrapper.__doc__, view.__doc__)
+        result = wrapper(None, None)
+        self.assertEqual(result.context, None)
+        self.assertEqual(result.request, None)
+        self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
+        self.assertEqual(regadapt['args'][3], IView)
+        self.assertEqual(regadapt['args'][4], '')
+        self.assertEqual(regadapt['args'][5], None)
+
     def test_request_type(self):
         context = DummyContext()
         class IFoo: