- Change how ``bfg_view`` decorator works when used as a class method

  decorator.  In 1.1a7, it actually tried to grope every class in
  scanned package at startup time looking for methods, which led to
  some strange symptoms (e.g. ``AttributeError: object has no
  attribute __provides__``).  Now, instead of groping methods at
  startup time, we just cause the ``bfg_view`` decorator itself to
  populate its class' __dict__ when its used inside a class as a
  method decorator.  This is essentially a reversion back to 1.1a6
  "grokking" behavior plus some special magic for using the
  ``bfg_view`` decorator as method decorator inside the ``bfg_view``
  class itself.

2 files changed, 16 insertions, 137 deletions

diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index 7b9597194..bbef24359 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -412,12 +412,25 @@ class TestBFGViewDecorator(unittest.TestCase):
         wrapped2 = decorator2(wrapped1)
         self.failUnless(wrapped1 is foo)
         self.failUnless(wrapped2 is foo)
-        self.assertEqual(len(wrapped2.__bfg_view_settings__), 2)
-        settings1 = wrapped2.__bfg_view_settings__[0]
+        self.assertEqual(len(foo.__bfg_view_settings__), 2)
+        settings1 = foo.__bfg_view_settings__[0]
         self.assertEqual(settings1['name'], '1')
-        settings2 = wrapped2.__bfg_view_settings__[1]
+        settings2 = foo.__bfg_view_settings__[1]
         self.assertEqual(settings2['name'], '2')
 
+    def test_call_as_method(self):
+        decorator = self._makeOne()
+        def foo(self): pass
+        def bar(self): pass
+        class foo(object):
+            """ docstring """
+            foomethod = decorator(foo)
+            barmethod = decorator(bar)
+        settings = foo.__bfg_view_settings__
+        self.assertEqual(len(settings), 2)
+        self.assertEqual(settings[0]['attr'], 'foo')
+        self.assertEqual(settings[1]['attr'], 'bar')
+
 class TestDefaultForbiddenView(unittest.TestCase):
     def _callFUT(self, context, request):
         from repoze.bfg.view import default_forbidden_view
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index d6eb80c44..aed4758f4 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -2413,98 +2413,6 @@ 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()
@@ -2544,48 +2452,6 @@ class TestExcludeFunction(unittest.TestCase):
         self.assertEqual(self._callFUT('.foo'), True)
         self.assertEqual(self._callFUT('foo'), False)
 
-class TestGetMembersFunction(unittest.TestCase):
-    def _callFUT(self, object, predicate=None):
-        from repoze.bfg.zcml import getmembers
-        return getmembers(object, predicate)
-
-    def test_with_attribute_error(self):
-        class Dummy:
-            @property
-            def raises(self):
-                raise AttributeError('raises')
-        ob = Dummy()
-        result = self._callFUT(ob, None)
-        result.sort()
-        self.assertEqual(result,
-                         [('__doc__', None),
-                          ('__module__', 'repoze.bfg.tests.test_zcml')]
-                         )
-
-    def test_without_attribute_error(self):
-        class Dummy:
-            def doesntraise(self):
-                pass
-        ob = Dummy()
-        result = self._callFUT(ob, None)
-        result.sort()
-        self.assertEqual(result,
-                         [('__doc__', None),
-                          ('__module__', 'repoze.bfg.tests.test_zcml'),
-                          ('doesntraise', ob.doesntraise)]
-                         )
-
-    def test_predicate(self):
-        class Dummy:
-            def doesntraise(self):
-                pass
-        ob = Dummy()
-        def predicate(testing):
-            return getattr(testing, '__name__', None) == 'doesntraise'
-        result = self._callFUT(ob, predicate)
-        result.sort()
-        self.assertEqual(result,[('doesntraise', ob.doesntraise)])
-
 class DummyModule:
     __path__ = "foo"
     __name__ = "dummy"