Turn wrapper methods back into functions to avoid keeping around references

to Configurator in closures.

4 files changed, 559 insertions, 574 deletions

diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py
index b272bee52..3d4f477e9 100644
--- a/repoze/bfg/configuration.py
+++ b/repoze/bfg/configuration.py
@@ -67,26 +67,20 @@ class Configurator(object):
     """ A wrapper around the registry that performs configuration tasks """
     def __init__(self, registry=None):
         self.package = caller_package()
-        if registry is None:
-            registry = self.make_default_registry()
         self.reg = registry
-        try:
-            # yes, a cycle; see get_configurator
-            self.reg['bfg_configurator'] = self
-        except TypeError:
-            pass
+        if registry is None:
+            registry = Registry(self.package.__name__)
+            self.reg = registry
+            self._default_configuration()
 
-    def make_default_registry(self):
-        self.reg = Registry()
+    def _default_configuration(self):
         self.renderer(chameleon_zpt.renderer_factory, '.pt')
         self.renderer(chameleon_text.renderer_factory, '.txt')
         self.renderer(renderers.json_renderer_factory, 'json')
         self.renderer(renderers.string_renderer_factory, 'string')
-        settings = Settings({})
-        self.settings(settings)
+        self.settings(Settings({}))
         self.root_factory(DefaultRootFactory)
         self.debug_logger(None)
-        return self.reg
 
     def make_wsgi_app(self, manager=manager, getSiteManager=getSiteManager):
         # manager and getSiteManager in arglist for testing dep injection only
@@ -109,7 +103,7 @@ class Configurator(object):
                     settings=None, debug_logger=None, os=os,
                     lock=threading.Lock()):
 
-        self.make_default_registry()
+        self._default_configuration()
 
         # debug_logger, os and lock *only* for unittests
         if settings is None:
@@ -243,213 +237,38 @@ class Configurator(object):
             self.reg.registerAdapter(multiview, (for_, request_type),
                                      IMultiView, name, info=_info)
 
+    def derive_view(self, view, permission=None, predicates=(),
+                    attr=None, renderer_name=None, wrapper_viewname=None,
+                    viewname=None):
+        renderer = self.renderer_from_name(renderer_name)
+        reg = self.reg
+        mapped_view = _map_view(reg, view, attr, renderer, renderer_name)
+        owrapped_view = _owrap_view(reg, mapped_view, viewname,wrapper_viewname)
+        secured_view = _secure_view(reg, owrapped_view, permission)
+        debug_view = _authdebug_view(reg, secured_view, permission)
+        derived_view = _predicate_wrap(reg, debug_view, predicates)
+        return derived_view
+
     def renderer_from_name(self, path_or_spec):
+        if path_or_spec is None:
+            # check for global default renderer
+            factory = self.reg.queryUtility(IRendererFactory)
+            if factory is not None:
+                return factory(path_or_spec)
+            return None
+
         if '.' in path_or_spec:
             name = os.path.splitext(path_or_spec)[1]
             spec = self.make_spec(path_or_spec)
         else:
             name = path_or_spec
             spec = path_or_spec
+
         factory = self.reg.queryUtility(IRendererFactory, name=name)
         if factory is None:
             raise ValueError('No renderer for renderer name %r' % name)
         return factory(spec)
 
-    def derive_view(self, original_view, permission=None, predicates=(),
-                    attr=None, renderer_name=None, wrapper_viewname=None,
-                    viewname=None):
-        mapped_view = self._map_view(original_view, attr, renderer_name)
-        owrapped_view = self._owrap_view(mapped_view, viewname,wrapper_viewname)
-        secured_view = self._secure_view(owrapped_view, permission)
-        debug_view = self._authdebug_view(secured_view, permission)
-        derived_view = self._predicate_wrap(debug_view, predicates)
-        return derived_view
-
-    def _map_view(self, view, attr=None, renderer_name=None):
-        wrapped_view = view
-
-        renderer = None
-
-        if renderer_name is None:
-            # global default renderer
-            factory = self.reg.queryUtility(IRendererFactory)
-            if factory is not None:
-                renderer_name = ''
-                renderer = factory(renderer_name)
-        else:
-            renderer = self.renderer_from_name(renderer_name)
-
-        if inspect.isclass(view):
-            # If the object we've located is a class, turn it into a
-            # function that operates like a Zope view (when it's invoked,
-            # construct an instance using 'context' and 'request' as
-            # position arguments, then immediately invoke the __call__
-            # method of the instance with no arguments; __call__ should
-            # return an IResponse).
-            if requestonly(view, attr):
-                # its __init__ accepts only a single request argument,
-                # instead of both context and request
-                def _bfg_class_requestonly_view(context, request):
-                    inst = view(request)
-                    if attr is None:
-                        response = inst()
-                    else:
-                        response = getattr(inst, attr)()
-                    if renderer is not None:
-                        response = rendered_response(renderer, 
-                                                     response, inst,
-                                                     context, request,
-                                                     renderer_name)
-                    return response
-                wrapped_view = _bfg_class_requestonly_view
-            else:
-                # its __init__ accepts both context and request
-                def _bfg_class_view(context, request):
-                    inst = view(context, request)
-                    if attr is None:
-                        response = inst()
-                    else:
-                        response = getattr(inst, attr)()
-                    if renderer is not None:
-                        response = rendered_response(renderer, 
-                                                     response, inst,
-                                                     context, request,
-                                                     renderer_name)
-                    return response
-                wrapped_view = _bfg_class_view
-
-        elif requestonly(view, attr):
-            # its __call__ accepts only a single request argument,
-            # instead of both context and request
-            def _bfg_requestonly_view(context, request):
-                if attr is None:
-                    response = view(request)
-                else:
-                    response = getattr(view, attr)(request)
-
-                if renderer is not None:
-                    response = rendered_response(renderer,
-                                                 response, view,
-                                                 context, request,
-                                                 renderer_name)
-                return response
-            wrapped_view = _bfg_requestonly_view
-
-        elif attr:
-            def _bfg_attr_view(context, request):
-                response = getattr(view, attr)(context, request)
-                if renderer is not None:
-                    response = rendered_response(renderer, 
-                                                 response, view,
-                                                 context, request,
-                                                 renderer_name)
-                return response
-            wrapped_view = _bfg_attr_view
-
-        elif renderer is not None:
-            def _rendered_view(context, request):
-                response = view(context, request)
-                response = rendered_response(renderer, 
-                                             response, view,
-                                             context, request,
-                                             renderer_name)
-                return response
-            wrapped_view = _rendered_view
-
-        decorate_view(wrapped_view, view)
-        return wrapped_view
-
-    def _owrap_view(self, view, viewname, wrapper_viewname):
-        if not wrapper_viewname:
-            return view
-        def _owrapped_view(context, request):
-            response = view(context, request)
-            request.wrapped_response = response
-            request.wrapped_body = response.body
-            request.wrapped_view = view
-            wrapped_response = render_view_to_response(context, request,
-                                                       wrapper_viewname)
-            if wrapped_response is None:
-                raise ValueError(
-                    'No wrapper view named %r found when executing view '
-                    'named %r' % (wrapper_viewname, viewname))
-            return wrapped_response
-        decorate_view(_owrapped_view, view)
-        return _owrapped_view
-
-    def _predicate_wrap(self, view, predicates):
-        if not predicates:
-            return view
-        def _wrapped(context, request):
-            if all((predicate(context, request) for predicate in predicates)):
-                return view(context, request)
-            raise NotFound('predicate mismatch for view %s' % view)
-        def checker(context, request):
-            return all((predicate(context, request) for predicate in
-                        predicates))
-        _wrapped.__predicated__ = checker
-        decorate_view(_wrapped, view)
-        return _wrapped
-
-    def _secure_view(self, view, permission):
-        wrapped_view = view
-        authn_policy = self.reg.queryUtility(IAuthenticationPolicy)
-        authz_policy = self.reg.queryUtility(IAuthorizationPolicy)
-        if authn_policy and authz_policy and (permission is not None):
-            def _secured_view(context, request):
-                principals = authn_policy.effective_principals(request)
-                if authz_policy.permits(context, principals, permission):
-                    return view(context, request)
-                msg = getattr(request, 'authdebug_message',
-                              'Unauthorized: %s failed permission check' % view)
-                raise Forbidden(msg)
-            _secured_view.__call_permissive__ = view
-            def _permitted(context, request):
-                principals = authn_policy.effective_principals(request)
-                return authz_policy.permits(context, principals, permission)
-            _secured_view.__permitted__ = _permitted
-            wrapped_view = _secured_view
-            decorate_view(wrapped_view, view)
-
-        return wrapped_view
-
-    def _authdebug_view(self, view, permission):
-        wrapped_view = view
-        authn_policy = self.reg.queryUtility(IAuthenticationPolicy)
-        authz_policy = self.reg.queryUtility(IAuthorizationPolicy)
-        settings = self.reg.queryUtility(ISettings)
-        debug_authorization = False
-        if settings is not None:
-            debug_authorization = settings.get('debug_authorization', False)
-        if debug_authorization:
-            def _authdebug_view(context, request):
-                view_name = getattr(request, 'view_name', None)
-
-                if authn_policy and authz_policy:
-                    if permission is None:
-                        msg = 'Allowed (no permission registered)'
-                    else:
-                        principals = authn_policy.effective_principals(request)
-                        msg = str(authz_policy.permits(context, principals,
-                                                       permission))
-                else:
-                    msg = 'Allowed (no authorization policy in use)'
-
-                view_name = getattr(request, 'view_name', None)
-                url = getattr(request, 'url', None)
-                msg = ('debug_authorization of url %s (view name %r against '
-                       'context %r): %s' % (url, view_name, context, msg))
-                logger = self.reg.queryUtility(ILogger, 'repoze.bfg.debug')
-                logger and logger.debug(msg)
-                if request is not None:
-                    request.authdebug_message = msg
-                return view(context, request)
-
-            wrapped_view = _authdebug_view
-            decorate_view(wrapped_view, view)
-
-        return wrapped_view
-
     def route(self, name, path, view=None, view_for=None,
               permission=None, factory=None, for_=None,
               header=None, xhr=False, accept=None, path_info=None,
@@ -869,3 +688,177 @@ def requestonly(class_or_callable, attr=None):
 
     return False
 
+def _map_view(registry, view, attr=None, renderer=None, renderer_name=None):
+    wrapped_view = view
+
+    if inspect.isclass(view):
+        # If the object we've located is a class, turn it into a
+        # function that operates like a Zope view (when it's invoked,
+        # construct an instance using 'context' and 'request' as
+        # position arguments, then immediately invoke the __call__
+        # method of the instance with no arguments; __call__ should
+        # return an IResponse).
+        if requestonly(view, attr):
+            # its __init__ accepts only a single request argument,
+            # instead of both context and request
+            def _bfg_class_requestonly_view(context, request):
+                inst = view(request)
+                if attr is None:
+                    response = inst()
+                else:
+                    response = getattr(inst, attr)()
+                if renderer is not None:
+                    response = rendered_response(renderer, 
+                                                 response, inst,
+                                                 context, request,
+                                                 renderer_name)
+                return response
+            wrapped_view = _bfg_class_requestonly_view
+        else:
+            # its __init__ accepts both context and request
+            def _bfg_class_view(context, request):
+                inst = view(context, request)
+                if attr is None:
+                    response = inst()
+                else:
+                    response = getattr(inst, attr)()
+                if renderer is not None:
+                    response = rendered_response(renderer, 
+                                                 response, inst,
+                                                 context, request,
+                                                 renderer_name)
+                return response
+            wrapped_view = _bfg_class_view
+
+    elif requestonly(view, attr):
+        # its __call__ accepts only a single request argument,
+        # instead of both context and request
+        def _bfg_requestonly_view(context, request):
+            if attr is None:
+                response = view(request)
+            else:
+                response = getattr(view, attr)(request)
+
+            if renderer is not None:
+                response = rendered_response(renderer,
+                                             response, view,
+                                             context, request,
+                                             renderer_name)
+            return response
+        wrapped_view = _bfg_requestonly_view
+
+    elif attr:
+        def _bfg_attr_view(context, request):
+            response = getattr(view, attr)(context, request)
+            if renderer is not None:
+                response = rendered_response(renderer, 
+                                             response, view,
+                                             context, request,
+                                             renderer_name)
+            return response
+        wrapped_view = _bfg_attr_view
+
+    elif renderer is not None:
+        def _rendered_view(context, request):
+            response = view(context, request)
+            response = rendered_response(renderer, 
+                                         response, view,
+                                         context, request,
+                                         renderer_name)
+            return response
+        wrapped_view = _rendered_view
+
+    decorate_view(wrapped_view, view)
+    return wrapped_view
+
+def _owrap_view(registry, view, viewname, wrapper_viewname):
+    if not wrapper_viewname:
+        return view
+    def _owrapped_view(context, request):
+        response = view(context, request)
+        request.wrapped_response = response
+        request.wrapped_body = response.body
+        request.wrapped_view = view
+        wrapped_response = render_view_to_response(context, request,
+                                                   wrapper_viewname)
+        if wrapped_response is None:
+            raise ValueError(
+                'No wrapper view named %r found when executing view '
+                'named %r' % (wrapper_viewname, viewname))
+        return wrapped_response
+    decorate_view(_owrapped_view, view)
+    return _owrapped_view
+
+def _predicate_wrap(registry, view, predicates):
+    if not predicates:
+        return view
+    def _wrapped(context, request):
+        if all((predicate(context, request) for predicate in predicates)):
+            return view(context, request)
+        raise NotFound('predicate mismatch for view %s' % view)
+    def checker(context, request):
+        return all((predicate(context, request) for predicate in
+                    predicates))
+    _wrapped.__predicated__ = checker
+    decorate_view(_wrapped, view)
+    return _wrapped
+
+def _secure_view(registry, view, permission):
+    wrapped_view = view
+    authn_policy = registry.queryUtility(IAuthenticationPolicy)
+    authz_policy = registry.queryUtility(IAuthorizationPolicy)
+    if authn_policy and authz_policy and (permission is not None):
+        def _secured_view(context, request):
+            principals = authn_policy.effective_principals(request)
+            if authz_policy.permits(context, principals, permission):
+                return view(context, request)
+            msg = getattr(request, 'authdebug_message',
+                          'Unauthorized: %s failed permission check' % view)
+            raise Forbidden(msg)
+        _secured_view.__call_permissive__ = view
+        def _permitted(context, request):
+            principals = authn_policy.effective_principals(request)
+            return authz_policy.permits(context, principals, permission)
+        _secured_view.__permitted__ = _permitted
+        wrapped_view = _secured_view
+        decorate_view(wrapped_view, view)
+
+    return wrapped_view
+
+def _authdebug_view(registry, view, permission):
+    wrapped_view = view
+    authn_policy = registry.queryUtility(IAuthenticationPolicy)
+    authz_policy = registry.queryUtility(IAuthorizationPolicy)
+    settings = registry.queryUtility(ISettings)
+    debug_authorization = False
+    if settings is not None:
+        debug_authorization = settings.get('debug_authorization', False)
+    if debug_authorization:
+        def _authdebug_view(context, request):
+            view_name = getattr(request, 'view_name', None)
+
+            if authn_policy and authz_policy:
+                if permission is None:
+                    msg = 'Allowed (no permission registered)'
+                else:
+                    principals = authn_policy.effective_principals(request)
+                    msg = str(authz_policy.permits(context, principals,
+                                                   permission))
+            else:
+                msg = 'Allowed (no authorization policy in use)'
+
+            view_name = getattr(request, 'view_name', None)
+            url = getattr(request, 'url', None)
+            msg = ('debug_authorization of url %s (view name %r against '
+                   'context %r): %s' % (url, view_name, context, msg))
+            logger =registry.queryUtility(ILogger, 'repoze.bfg.debug')
+            logger and logger.debug(msg)
+            if request is not None:
+                request.authdebug_message = msg
+            return view(context, request)
+
+        wrapped_view = _authdebug_view
+        decorate_view(wrapped_view, view)
+
+    return wrapped_view
+
diff --git a/repoze/bfg/path.py b/repoze/bfg/path.py
index cdc0cd1ea..b4ff40494 100644
--- a/repoze/bfg/path.py
+++ b/repoze/bfg/path.py
@@ -34,7 +34,7 @@ def package_name(pkg_or_module):
 def caller_package(level=2, caller_module=caller_module):
     # caller_module in arglist for tests
     module = caller_module(level+1)
-    if '__init__.py' in module.__file__:
+    if '__init__.py' in getattr(module, '__file__', ''): # empty at >>>
         # Module is a package
         return module
     # Go up one level to get package
diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index e427823fa..802f21915 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -96,10 +96,14 @@ class ConfiguratorTests(unittest.TestCase):
         config = Configurator()
         self.failUnless(config.reg.getUtility(ISettings))
 
-    def test_make_default_registry(self):
-        config = self._makeOne()
-        reg = config.make_default_registry()
-        self.assertEqual(config.reg, reg)
+    def test__default_configuration(self):
+        from repoze.bfg.interfaces import ISettings
+        from repoze.bfg.registry import Registry
+        registry = Registry()
+        config = self._makeOne(registry)
+        config._default_configuration()
+        self.assertEqual(config.reg, registry)
+        self.failIf(config.reg.getUtility(ISettings) is None)
 
     def test_make_wsgi_app(self):
         from repoze.bfg.threadlocal import get_current_registry
@@ -939,343 +943,6 @@ class ConfiguratorTests(unittest.TestCase):
         route = self._assertRoute(config, 'name', 'path')
         self.failUnless(hasattr(wrapper, '__call_permissive__'))
 
-    def test__map_view_as_function_context_and_request(self):
-        def view(context, request):
-            return 'OK'
-        config = self._makeOne()
-        result = config._map_view(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_function_with_attr(self):
-        def view(context, request):
-            """ """
-        config = self._makeOne()
-        result = config._map_view(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test__map_view_as_function_with_attr_and_renderer(self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        view = lambda *arg: 'OK'
-        result = config._map_view(view, attr='__name__',
-                                 renderer_name='fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-        
-    def test__map_view_as_function_requestonly(self):
-        config = self._makeOne()
-        def view(request):
-            return 'OK'
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_function_requestonly_with_attr(self):
-        config = self._makeOne()
-        def view(request):
-            """ """
-        result = config._map_view(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test__map_view_as_newstyle_class_context_and_request(self):
-        config = self._makeOne()
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_newstyle_class_context_and_request_with_attr(self):
-        config = self._makeOne()
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer(
-        self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-        
-    def test__map_view_as_newstyle_class_requestonly(self):
-        config = self._makeOne()
-        class view(object):
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_newstyle_class_requestonly_with_attr(self):
-        config = self._makeOne()
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_newstyle_class_requestonly_with_attr_and_renderer(
-        self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_as_oldstyle_class_context_and_request(self):
-        config = self._makeOne()
-        class view:
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_oldstyle_class_context_and_request_with_attr(self):
-        config = self._makeOne()
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
-        self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_as_oldstyle_class_requestonly(self):
-        config = self._makeOne()
-        class view:
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_oldstyle_class_requestonly_with_attr(self):
-        config = self._makeOne()
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_as_instance_context_and_request(self):
-        config = self._makeOne()
-        class View:
-            def __call__(self, context, request):
-                return 'OK'
-        view = View()
-        result = config._map_view(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-        
-    def test__map_view_as_instance_context_and_request_and_attr(self):
-        config = self._makeOne()
-        class View:
-            def index(self, context, request):
-                return 'OK'
-        view = View()
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_instance_context_and_request_attr_and_renderer(self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class View:
-            def index(self, context, request):
-                return {'a':'1'}
-        view = View()
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_as_instance_requestonly(self):
-        config = self._makeOne()
-        class View:
-            def __call__(self, request):
-                return 'OK'
-        view = View()
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_instance_requestonly_with_attr(self):
-        config = self._makeOne()
-        class View:
-            def index(self, request):
-                return 'OK'
-        view = View()
-        result = config._map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test__map_view_as_instance_requestonly_with_attr_and_renderer(self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        class View:
-            def index(self, request):
-                return {'a':'1'}
-        view = View()
-        result = config._map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_rendereronly(self):
-        config = self._makeOne()
-        self._registerRenderer(config)
-        def view(context, request):
-            return {'a':'1'}
-        result = config._map_view(
-            view,
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test__map_view_defaultrendereronly(self):
-        config = self._makeOne()
-        self._registerRenderer(config, name='')
-        def view(context, request):
-            return {'a':'1'}
-        result = config._map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = self._makeRequest(config)
-        self.assertEqual(result(None, request).body, 'Hello!')
-
     def test__override_not_yet_registered(self):
         from repoze.bfg.interfaces import IPackageOverrides
         package = DummyPackage('package')
@@ -1759,6 +1426,343 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(override.override_package, subpackage)
         self.assertEqual(override.override_prefix, 'templates/bar.pt')
 
+class Test__map_view(unittest.TestCase):
+    def setUp(self):
+        from repoze.bfg.registry import Registry
+        self.registry = Registry()
+
+    def tearDown(self):
+        del self.registry
+        
+    def _registerRenderer(self, name='.txt'):
+        from repoze.bfg.interfaces import IRendererFactory
+        from repoze.bfg.interfaces import ITemplateRenderer
+        from zope.interface import implements
+        class Renderer:
+            implements(ITemplateRenderer)
+            def __init__(self, path):
+                self.__class__.path = path
+            def __call__(self, *arg):
+                return 'Hello!'
+        self.registry.registerUtility(Renderer, IRendererFactory, name=name)
+        return Renderer(name)
+
+    def _makeRequest(self):
+        request = DummyRequest()
+        request.registry = self.registry
+        return request
+
+    def _callFUT(self, *arg, **kw):
+        from repoze.bfg.configuration import _map_view
+        return _map_view(*arg, **kw)
+    
+    def test__map_view_as_function_context_and_request(self):
+        def view(context, request):
+            return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_function_with_attr(self):
+        def view(context, request):
+            """ """
+        result = self._callFUT(self.registry, view, attr='__name__')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test__map_view_as_function_with_attr_and_renderer(self):
+        self._registerRenderer()
+        view = lambda *arg: 'OK'
+        result = self._callFUT(self.registry, view, attr='__name__',
+                                 renderer_name='fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+        
+    def test__map_view_as_function_requestonly(self):
+        def view(request):
+            return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_function_requestonly_with_attr(self):
+        def view(request):
+            """ """
+        result = self._callFUT(self.registry, view, attr='__name__')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test__map_view_as_newstyle_class_context_and_request(self):
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_newstyle_class_context_and_request_with_attr(self):
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer(
+        self):
+        renderer = self._registerRenderer()
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer = renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+        
+    def test__map_view_as_newstyle_class_requestonly(self):
+        class view(object):
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_newstyle_class_requestonly_with_attr(self):
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_newstyle_class_requestonly_attr_and_renderer(self):
+        renderer = self._registerRenderer()
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer = renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_as_oldstyle_class_context_and_request(self):
+        class view:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_oldstyle_class_context_and_request_with_attr(self):
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_oldstyle_cls_context_request_attr_and_renderer(self):
+        renderer = self._registerRenderer()
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer = renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_as_oldstyle_class_requestonly(self):
+        class view:
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_oldstyle_class_requestonly_with_attr(self):
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
+        renderer = self._registerRenderer()
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer = renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_as_instance_context_and_request(self):
+        class View:
+            def __call__(self, context, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(self.registry, view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+        
+    def test__map_view_as_instance_context_and_request_and_attr(self):
+        class View:
+            def index(self, context, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_instance_context_and_request_attr_and_renderer(self):
+        renderer = self._registerRenderer()
+        class View:
+            def index(self, context, request):
+                return {'a':'1'}
+        view = View()
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer=renderer)
+        self.failIf(result is view)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_as_instance_requestonly(self):
+        class View:
+            def __call__(self, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(self.registry, view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_instance_requestonly_with_attr(self):
+        class View:
+            def index(self, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(self.registry, view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test__map_view_as_instance_requestonly_with_attr_and_renderer(self):
+        renderer = self._registerRenderer()
+        class View:
+            def index(self, request):
+                return {'a':'1'}
+        view = View()
+        result = self._callFUT(
+            self.registry,
+            view, attr='index',
+            renderer = renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test__map_view_rendereronly(self):
+        renderer = self._registerRenderer()
+        def view(context, request):
+            return {'a':'1'}
+        result = self._callFUT(
+            self.registry,
+            view,
+            renderer=renderer)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = self._makeRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+
 class TestBFGViewGrokker(unittest.TestCase):
     def setUp(self):
         cleanUp()
diff --git a/repoze/bfg/zcml.py b/repoze/bfg/zcml.py
index f801c62ac..77ac4c8fa 100644
--- a/repoze/bfg/zcml.py
+++ b/repoze/bfg/zcml.py
@@ -24,6 +24,7 @@ from repoze.bfg.authentication import RepozeWho1AuthenticationPolicy
 from repoze.bfg.authentication import RemoteUserAuthenticationPolicy
 from repoze.bfg.authentication import AuthTktAuthenticationPolicy
 from repoze.bfg.authorization import ACLAuthorizationPolicy
+from repoze.bfg.configuration import Configurator
 from repoze.bfg.request import route_request_iface
 from repoze.bfg.threadlocal import get_current_registry
 from repoze.bfg.static import StaticRootFactory
@@ -163,7 +164,7 @@ def view(
         renderer = _context.path(renderer)
 
     def register():
-        config = get_configurator(reg)
+        config = Configurator(reg)
         config.view(
             permission=permission, for_=for_, view=view, name=name,
             request_type=request_type, route_name=route_name,
@@ -242,7 +243,7 @@ def route(_context, name, path, view=None, view_for=None,
         view_renderer = _context.path(view_renderer)
 
     def register():
-        config = get_configurator(reg)
+        config = Configurator(reg)
         config.route(
             name,
             path,
@@ -320,7 +321,7 @@ class SystemViewHandler(object):
 
         def register(iface=self.iface):
             reg = get_current_registry()
-            config = get_configurator(reg)
+            config = Configurator(reg)
             config.system_view(iface, view=view, attr=attr, renderer=renderer,
                                wrapper=wrapper, _info=_context.info)
 
@@ -348,7 +349,7 @@ class IResourceDirective(Interface):
 
 def resource(_context, to_override, override_with):
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
 
     _context.action(
         discriminator = None,
@@ -368,7 +369,7 @@ def repozewho1authenticationpolicy(_context, identifier_name='auth_tkt',
     # authentication policies must be registered eagerly so they can
     # be found by the view registration machinery
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
     config.authentication_policy(policy, _info=_context.info)
     _context.action(discriminator=IAuthenticationPolicy)
 
@@ -384,7 +385,7 @@ def remoteuserauthenticationpolicy(_context, environ_key='REMOTE_USER',
     # authentication policies must be registered eagerly so they can
     # be found by the view registration machinery
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
     config.authentication_policy(policy, _info=_context.info)
     _context.action(discriminator=IAuthenticationPolicy)
 
@@ -422,7 +423,7 @@ def authtktauthenticationpolicy(_context,
     # authentication policies must be registered eagerly so they can
     # be found by the view registration machinery
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
     config.authentication_policy(policy, _info=_context.info)
     _context.action(discriminator=IAuthenticationPolicy)
 
@@ -434,7 +435,7 @@ def aclauthorizationpolicy(_context):
     # authorization policies must be registered eagerly so they can be
     # found by the view registration machinery
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
     config.authorization_policy(policy, _info=_context.info)
     _context.action(discriminator=IAuthorizationPolicy)
 
@@ -451,7 +452,7 @@ def renderer(_context, factory, name=''):
     # renderer factories must be registered eagerly so they can be
     # found by the view machinery
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
     config.renderer(factory, name, _info=_context.info)
     _context.action(discriminator=(IRendererFactory, name))
 
@@ -479,7 +480,7 @@ def static(_context, name, path, cache_max_age=3600):
     """
     abspath = _context.path(path)
     reg = get_current_registry()
-    config = get_configurator(reg)
+    config = Configurator(reg)
 
     _context.action(
         discriminator = ('route', name, False, None, None, None, None, None),
@@ -504,7 +505,7 @@ def scan(_context, package, martian=martian):
     # martian overrideable only for unit tests
     def register():
         reg = get_current_registry()
-        config = get_configurator(reg)
+        config = Configurator(reg)
         config.scan(package, _info=_context.info, martian=martian)
     _context.action(discriminator=None, callable=register)
 
@@ -524,16 +525,3 @@ def zcml_configure(name, package):
 
 file_configure = zcml_configure # backwards compat (>0.8.1)
 
-def get_configurator(reg):
-    # dont create a new configurator instance unless necessary, as
-    # frames will point to each configurator instance via closures
-    # when some configuration methods (such as config.view) are
-    # called.
-    from repoze.bfg.configuration import Configurator
-    try:
-        config = reg.get('bfg_configurator')
-    except:
-        config = None
-    if config is None:
-        config = Configurator(reg)
-    return config