- Use "Venusian" (`http://docs.repoze.org/venusian

  <http://docs.repoze.org/venusian>`) to perform ``bfg_view``
  decorator scanning rather than relying on a BFG-internal decorator
  scanner.  (Truth be told, Venusian is really just a generalization
  of the BFG-internal decorator scanner).

- A new install-time dependency on the ``venusian`` distribution was
  added.

- Remove ``repoze.bfg.compat.pkgutil_26.py`` and import alias
  ``repoze.bfg.compat.walk_packages``.  These were only required by
  internal scanning machinery; Venusian replaced the internal scanning
  machinery, so these are no longer required.

3 files changed, 93 insertions, 50 deletions

diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index c54509378..b6eb860ee 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -20,8 +20,9 @@ def wsgiapptest(environ, start_response):
 
 class WGSIAppPlusBFGViewTests(unittest.TestCase):
     def test_it(self):
+        from venusian import ATTACH_ATTR
         import types
-        self.failUnless(wsgiapptest.__bfg_view_settings__)
+        self.failUnless(getattr(wsgiapptest, ATTACH_ATTR))
         self.failUnless(type(wsgiapptest) is types.FunctionType)
         context = DummyContext()
         request = DummyRequest()
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index bcfa45e91..76a218cf6 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -1,4 +1,5 @@
 import unittest
+import sys
 
 from repoze.bfg.testing import cleanUp
 
@@ -302,100 +303,109 @@ class TestBFGViewDecorator(unittest.TestCase):
         
     def test_call_function(self):
         decorator = self._makeOne()
-        def foo():
-            """ docstring """
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        def foo(): pass
         wrapped = decorator(foo)
         self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['permission'], None)
-        self.assertEqual(settings['context'], None)
-        self.assertEqual(settings['request_type'], None)
+        settings = call_venusian(venusian)
+        self.assertEqual(len(settings), 1)
+        self.assertEqual(settings[0]['permission'], None)
+        self.assertEqual(settings[0]['context'], None)
+        self.assertEqual(settings[0]['request_type'], None)
 
-    def test_call_oldstyle_class(self):
+    def test_call_class(self):
         decorator = self._makeOne()
-        class foo:
-            """ docstring """
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        decorator.venusian.info.scope = 'class'
+        class foo(object): pass
         wrapped = decorator(foo)
         self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['permission'], None)
-        self.assertEqual(settings['context'], None)
-        self.assertEqual(settings['request_type'], None)
-
-    def test_call_newstyle_class(self):
-        decorator = self._makeOne()
-        class foo(object):
-            """ docstring """
-        wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['permission'], None)
-        self.assertEqual(settings['context'], None)
-        self.assertEqual(settings['request_type'], None)
+        settings = call_venusian(venusian)
+        self.assertEqual(len(settings), 1)
+        self.assertEqual(settings[0]['permission'], None)
+        self.assertEqual(settings[0]['context'], None)
+        self.assertEqual(settings[0]['request_type'], None)
 
     def test_stacking(self):
         decorator1 = self._makeOne(name='1')
+        venusian1 = DummyVenusian()
+        decorator1.venusian = venusian1
+        venusian2 = DummyVenusian()
         decorator2 = self._makeOne(name='2')
-        def foo():
-            """ docstring """
+        decorator2.venusian = venusian2
+        def foo(): pass
         wrapped1 = decorator1(foo)
         wrapped2 = decorator2(wrapped1)
         self.failUnless(wrapped1 is foo)
         self.failUnless(wrapped2 is foo)
-        self.assertEqual(len(foo.__bfg_view_settings__), 2)
-        settings1 = foo.__bfg_view_settings__[0]
-        self.assertEqual(settings1['name'], '1')
-        settings2 = foo.__bfg_view_settings__[1]
-        self.assertEqual(settings2['name'], '2')
+        settings1 = call_venusian(venusian1)
+        self.assertEqual(len(settings1), 1)
+        self.assertEqual(settings1[0]['name'], '1')
+        settings2 = call_venusian(venusian2)
+        self.assertEqual(len(settings2), 1)
+        self.assertEqual(settings2[0]['name'], '2')
 
     def test_call_as_method(self):
         decorator = self._makeOne()
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        decorator.venusian.info.scope = 'class'
         def foo(self): pass
         def bar(self): pass
         class foo(object):
-            """ docstring """
             foomethod = decorator(foo)
             barmethod = decorator(bar)
-        settings = foo.__bfg_view_settings__
+        settings = call_venusian(venusian)
         self.assertEqual(len(settings), 2)
         self.assertEqual(settings[0]['attr'], 'foo')
         self.assertEqual(settings[1]['attr'], 'bar')
 
     def test_with_custom_predicates(self):
         decorator = self._makeOne(custom_predicates=(1,))
-        def foo(context, request): return 'OK'
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        def foo(context, request): pass
         decorated = decorator(foo)
-        settings = decorated.__bfg_view_settings__
+        self.failUnless(decorated is foo)
+        settings = call_venusian(venusian)
         self.assertEqual(settings[0]['custom_predicates'], (1,))
 
     def test_call_with_renderer_nodot(self):
         decorator = self._makeOne(renderer='json')
-        def foo():
-            """ docstring """
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        def foo(): pass
         wrapped = decorator(foo)
         self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['renderer'], 'json')
+        settings = call_venusian(venusian)
+        self.assertEqual(len(settings), 1)
+        self.assertEqual(settings[0]['renderer'], 'json')
 
     def test_call_with_renderer_relpath(self):
         decorator = self._makeOne(renderer='fixtures/minimal.pt')
-        def foo():
-            """ docstring """
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        def foo(): pass
         wrapped = decorator(foo)
         self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['renderer'],
+        settings = call_venusian(venusian)
+        self.assertEqual(len(settings), 1)
+        self.assertEqual(settings[0]['renderer'],
                          'repoze.bfg.tests:fixtures/minimal.pt')
 
     def test_call_with_renderer_pkgpath(self):
         decorator = self._makeOne(
             renderer='repoze.bfg.tests:fixtures/minimal.pt')
-        def foo():
-            """ docstring """
+        venusian = DummyVenusian()
+        decorator.venusian = venusian
+        def foo(): pass
         wrapped = decorator(foo)
         self.failUnless(wrapped is foo)
-        settings = wrapped.__bfg_view_settings__[0]
-        self.assertEqual(settings['renderer'],
+        settings = call_venusian(venusian)
+        self.assertEqual(len(settings), 1)
+        self.assertEqual(settings[0]['renderer'],
                          'repoze.bfg.tests:fixtures/minimal.pt')
 
 class TestDefaultForbiddenView(BaseTest, unittest.TestCase):
@@ -521,3 +531,36 @@ class DummyResponse:
 from zope.interface import Interface
 class IContext(Interface):
     pass
+
+class DummyVenusianInfo(object):
+    scope = 'notaclass'
+    module = sys.modules['repoze.bfg.tests']
+
+class DummyVenusian(object):
+    def __init__(self, info=None):
+        if info is None:
+            info = DummyVenusianInfo()
+        self.info = info
+        self.attachments = []
+
+    def attach(self, wrapped, callback, category=None):
+        self.attachments.append((wrapped, callback, category))
+        return self.info
+
+class DummyConfig(object):
+    def __init__(self):
+        self.settings = []
+
+    def add_view(self, **kw):
+        self.settings.append(kw)
+
+class DummyVenusianContext(object):
+    def __init__(self):
+        self.config = DummyConfig()
+        
+def call_venusian(venusian):
+    context = DummyVenusianContext()
+    for wrapped, callback, category in venusian.attachments:
+        callback(context, None, None)
+    return context.config.settings
+
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 452769de8..7f42e9f09 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -837,8 +837,7 @@ class TestZCMLScanDirective(unittest.TestCase):
         action = actions[0]
         self.assertEqual(action['callable'].im_func, Configurator.scan.im_func)
         self.assertEqual(action['discriminator'], None)
-        self.assertEqual(action['args'], (dummy_module, None))
-
+        self.assertEqual(action['args'], (dummy_module, None, None))
 
 class TestAdapterDirective(unittest.TestCase):
     def setUp(self):