- The ``@bfg_view`` decorator can now be used against a class method::

    from webob import Response
    from repoze.bfg.view import bfg_view

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

        @bfg_view(name='hello')
        def amethod(self):
            return Response('hello from %s!' % self.context)

  When the bfg_view decorator is used against a class method, a view
  is registered for the *class* (it's a "class view" where the "attr"
  happens to be the method they're attached to), so the view class
  must have a suitable constructor.

3 files changed, 146 insertions, 4 deletions

diff --git a/repoze/bfg/tests/grokkedapp/__init__.py b/repoze/bfg/tests/grokkedapp/__init__.py
index 5a00adbeb..5d2843885 100644
--- a/repoze/bfg/tests/grokkedapp/__init__.py
+++ b/repoze/bfg/tests/grokkedapp/__init__.py
@@ -52,6 +52,29 @@ class Foo(object):
 grokked_instance = Foo()
 grokked_instance = bfg_view(name='grokked_instance')(grokked_instance)
 
+class Base(object):
+    @bfg_view(name='basemethod')
+    def basemethod(self):
+        """ """
+    
+class MethodViews(Base):
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    @bfg_view(name='method1')
+    def method1(self):
+        return 'method1'
+
+    @bfg_view(name='method2')
+    def method2(self):
+        return 'method2'
+
+    @bfg_view(name='stacked_method2')
+    @bfg_view(name='stacked_method1')
+    def stacked(self):
+        return 'stacked_method'
+
 # ungrokkable
 
 A = 1
@@ -59,4 +82,9 @@ B = {}
 
 def stuff():
     """ """
-    
+
+class Whatever(object):
+    pass
+
+class Whatever2:
+    pass
diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index 691d64e24..f05601031 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -109,9 +109,8 @@ class TestGrokkedApp(unittest.TestCase):
         actions = zcml_configure('configure.zcml', package)
         actions.sort()
 
-        num = 18
+        num = 23
 
-        action_names = [actions[x][0][2] for x in range(len(actions[:num]))]
         action_types = [(actions[x][0][1],
                          actions[x][0][3],
                          actions[x][0][4]) for x in range(len(actions[:num]))]
@@ -119,6 +118,9 @@ class TestGrokkedApp(unittest.TestCase):
         for typ in action_types:
             self.assertEqual(typ, (None, IRequest, IView))
 
+        action_names = [actions[x][0][2] for x in range(len(actions[:num]))]
+        action_names.sort()
+
         self.assertEqual(
             action_names, [
                 '',
@@ -132,13 +134,18 @@ class TestGrokkedApp(unittest.TestCase):
                 'another_stacked2',
                 'another_stacked_class1',
                 'another_stacked_class2',
+                'basemethod',
                 'grokked_class',
                 'grokked_instance',
+                'method1',
+                'method2',
                 'oldstyle_grokked_class',
                 'stacked1',
                 'stacked2',
                 'stacked_class1',
                 'stacked_class2',
+                'stacked_method1',
+                'stacked_method2',
                 ]
             )
 
@@ -206,6 +213,21 @@ class TestGrokkedApp(unittest.TestCase):
         result = render_view_to_response(ctx, req, 'another_stacked_class2')
         self.assertEqual(result, 'another_stacked_class')
 
+        self.assertRaises(TypeError,
+                          render_view_to_response, ctx, req, 'basemethod')
+
+        result = render_view_to_response(ctx, req, 'method1')
+        self.assertEqual(result, 'method1')
+
+        result = render_view_to_response(ctx, req, 'method2')
+        self.assertEqual(result, 'method2')
+
+        result = render_view_to_response(ctx, req, 'stacked_method1')
+        self.assertEqual(result, 'stacked_method')
+
+        result = render_view_to_response(ctx, req, 'stacked_method2')
+        self.assertEqual(result, 'stacked_method')
+
 class DummyContext(object):
     pass
 
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 7538072ca..282c27472 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -2388,7 +2388,7 @@ class TestBFGViewGrokker(unittest.TestCase):
                         request_type=IRequest, route_name=None,
                         request_method=None, request_param=None,
                         containment=None, attr=None, renderer=None,
-                        wrapper_viewname=None, xhr=False, header=None,
+                        wrapper=None, xhr=False, header=None,
                         accept=None)
         obj.__bfg_view_settings__ = [settings]
         context = DummyContext()
@@ -2413,6 +2413,98 @@ class TestBFGViewGrokker(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 0)
 
+class TestBFGClassGrokker(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+
+    def _getTargetClass(self):
+        from repoze.bfg.zcml import BFGClassGrokker
+        return BFGClassGrokker
+
+    def _makeOne(self, *arg, **kw):
+        return self._getTargetClass()(*arg, **kw)
+
+    def test_calls_bfg_view_grokker(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        from zope.interface import Interface
+        class obj:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        settings = dict(permission='foo', for_=Interface, name='foo.html',
+                        request_type=IRequest, route_name=None,
+                        request_method=None, request_param=None,
+                        containment=None, attr=None, renderer=None,
+                        wrapper=None, xhr=False, header=None,
+                        accept=None)
+        obj.__bfg_view_settings__ = [settings]
+        grokker = self._makeOne()
+        context = DummyContext()
+        result = grokker.grok('name', obj, context=context)
+        self.assertEqual(result, True)
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+        register = actions[0]['callable']
+        register()
+        sm = getSiteManager()
+        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
+                                     name='foo.html')
+        self.assertEqual(wrapped(None, None), 'OK')
+
+    def test_it(self):
+        from repoze.bfg.interfaces import IRequest
+        from zope.component import getSiteManager
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IView
+        class base(object):
+            def basemethod(self):
+                """ """
+            basemethod.__bfg_view_settings__ = [
+                dict(permission=None, for_=Interface, name='basemethod',
+                     request_type=IRequest, route_name=None,
+                     request_method=None, request_param=None,
+                     containment=None, attr=None, renderer=None,
+                     wrapper=None, xhr=False, header=None,
+                     accept=None)
+                ]
+                
+        class obj(base):
+            def __init__(self, context, request):
+                pass
+            def foo(self):
+                return 'OK'
+            foo.__bfg_view_settings__ = [
+                dict(permission=None, for_=Interface, name='foo',
+                     request_type=IRequest, route_name=None,
+                     request_method=None, request_param=None,
+                     containment=None, attr=None, renderer=None,
+                     wrapper=None, xhr=False, header=None,
+                     accept=None)
+                ]
+
+        grokker = self._makeOne()
+        context = DummyContext()
+        result = grokker.grok('name', obj, context=context)
+        self.assertEqual(result, True)
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+        register = actions[0]['callable']
+        register()
+        sm = getSiteManager()
+        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
+                                     name='foo')
+        self.assertEqual(wrapped(None, None), 'OK')
+        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
+                                     name='basemethod')
+        # base methods not grokked
+        self.assertEqual(wrapped, None)
+
 class TestZCMLScanDirective(unittest.TestCase):
     def setUp(self):
         cleanUp()