- Internal: Chameleon template renderers now accept two arguments: ``path``

  and ``lookup``.  ``Lookup`` will be an instance of a lookup class which
  supplies (late-bound) arguments for debug, reload, and translate.  Any
  third-party renderers which use (the non-API) function
  ``pyramid.renderers.template_renderer_factory`` will need to adjust their
  implementations to obey the new callback argument list.  This change was to
  kill off inappropriate use of threadlocals.

8 files changed, 209 insertions, 147 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index e7c42d659..b9f6a69c7 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -68,6 +68,14 @@ Behavior Differences
   a ``registry`` attribute on the ZCML context (kill off use of
   threadlocals).
 
+- Internal: Chameleon template renderers now accept two arguments: ``path``
+  and ``lookup``.  ``Lookup`` will be an instance of a lookup class which
+  supplies (late-bound) arguments for debug, reload, and translate.  Any
+  third-party renderers which use (the non-API) function
+  ``pyramid.renderers.template_renderer_factory`` will need to adjust their
+  implementations to obey the new callback argument list.  This change was to
+  kill off inappropriate use of threadlocals.
+
 1.0a2 (2010-11-09)
 ==================
 
diff --git a/pyramid/chameleon_text.py b/pyramid/chameleon_text.py
index 91f5c279f..1f31f3add 100644
--- a/pyramid/chameleon_text.py
+++ b/pyramid/chameleon_text.py
@@ -21,13 +21,10 @@ except ImportError: # pragma: no cover
         pass
 
 from pyramid.interfaces import ITemplateRenderer
-from pyramid.interfaces import IChameleonTranslate
 
 from pyramid.decorator import reify
 from pyramid import renderers
 from pyramid.path import caller_package
-from pyramid.settings import get_settings
-from pyramid.threadlocal import get_current_registry
 
 class TextTemplateFile(TemplateFile):
     default_parser = Parser()
@@ -44,30 +41,19 @@ def renderer_factory(info):
 
 class TextTemplateRenderer(object):
     implements(ITemplateRenderer)
-    def __init__(self, path):
+    def __init__(self, path, lookup):
         self.path = path
+        self.lookup = lookup
 
     @reify # avoid looking up reload_templates before manager pushed
     def template(self):
         if sys.platform.startswith('java'): # pragma: no cover
             raise RuntimeError(
                 'Chameleon templates are not compatible with Jython')
-        settings = get_settings()
-        debug = False
-        auto_reload = False
-        if settings:
-            # using .get here is a strategy to be kind to old *tests* rather
-            # than being kind to any existing production system
-            auto_reload = settings.get('reload_templates')
-            debug = settings.get('debug_templates')
-        reg = get_current_registry()
-        translate = None
-        if reg is not None:
-            translate = reg.queryUtility(IChameleonTranslate)
         return TextTemplateFile(self.path,
-                                auto_reload=auto_reload,
-                                debug=debug,
-                                translate=translate)
+                                auto_reload=self.lookup.auto_reload,
+                                debug=self.lookup.debug,
+                                translate=self.lookup.translate)
 
     def implementation(self):
         return self.template
diff --git a/pyramid/chameleon_zpt.py b/pyramid/chameleon_zpt.py
index 172899d41..6aae59a87 100644
--- a/pyramid/chameleon_zpt.py
+++ b/pyramid/chameleon_zpt.py
@@ -1,4 +1,5 @@
 import sys
+import threading
 
 from zope.interface import implements
 
@@ -12,44 +13,32 @@ except ImportError: # pragma: no cover
         def __init__(self, *arg, **kw):
             raise ImportError, exc, tb
 
-from pyramid.interfaces import IChameleonTranslate
 from pyramid.interfaces import ITemplateRenderer
 
 from pyramid.decorator import reify
 from pyramid.path import caller_package
 from pyramid import renderers
-from pyramid.settings import get_settings
-from pyramid.threadlocal import get_current_registry
 
-def renderer_factory(info):
+registry_lock = threading.Lock()
+    
+def renderer_factory(info, lock=registry_lock):
     return renderers.template_renderer_factory(info, ZPTTemplateRenderer)
 
 class ZPTTemplateRenderer(object):
     implements(ITemplateRenderer)
-    def __init__(self, path):
+    def __init__(self, path, lookup):
         self.path = path
+        self.lookup = lookup
 
     @reify # avoid looking up reload_templates before manager pushed
     def template(self):
         if sys.platform.startswith('java'): # pragma: no cover
             raise RuntimeError(
                 'Chameleon templates are not compatible with Jython')
-        settings = get_settings()
-        debug = False
-        auto_reload = False
-        if settings:
-            # using .get here is a strategy to be kind to old *tests* rather
-            # than being kind to any existing production system
-            auto_reload = settings.get('reload_templates')
-            debug = settings.get('debug_templates')
-        reg = get_current_registry()
-        translate = None
-        if reg is not None:
-            translate = reg.queryUtility(IChameleonTranslate)
         return PageTemplateFile(self.path,
-                                auto_reload=auto_reload,
-                                debug=debug,
-                                translate=translate)
+                                auto_reload=self.lookup.auto_reload,
+                                debug=self.lookup.debug,
+                                translate=self.lookup.translate)
 
     def implementation(self):
         return self.template
diff --git a/pyramid/interfaces.py b/pyramid/interfaces.py
index 9835f8f7d..47bccf71f 100644
--- a/pyramid/interfaces.py
+++ b/pyramid/interfaces.py
@@ -392,6 +392,13 @@ class IPackageOverrides(Interface):
 # traversalwrapper)
 VH_ROOT_KEY = 'HTTP_X_VHM_ROOT'
 
+class IChameleonLookup(Interface):
+    translate = Attribute('IChameleonTranslate object')
+    debug = Attribute('The ``debug_templates`` setting for this application')
+    auto_reload = Attribute('The ``reload_templates`` setting for this app')
+    def __call__(self, info):
+        """ Return an ITemplateRenderer based on IRendererInfo ``info`` """
+
 class IChameleonTranslate(Interface):
     """ Internal interface representing a chameleon translate function """
     def __call__(msgid, domain=None, mapping=None, context=None,
diff --git a/pyramid/renderers.py b/pyramid/renderers.py
index 0c2a7c5db..94b58cf92 100644
--- a/pyramid/renderers.py
+++ b/pyramid/renderers.py
@@ -4,6 +4,8 @@ import threading
 
 from zope.interface import implements
 
+from pyramid.interfaces import IChameleonLookup
+from pyramid.interfaces import IChameleonTranslate
 from pyramid.interfaces import IRendererGlobalsFactory
 from pyramid.interfaces import IRendererFactory
 from pyramid.interfaces import IResponseFactory
@@ -150,66 +152,102 @@ def string_renderer_factory(info):
 
 # utility functions, not API
 
-# Lock to prevent simultaneous registry writes; used in
-# template_renderer_factory.  template_renderer_factory may be called
-# at runtime, from more than a single thread.
-registry_lock = threading.Lock() 
-
-def template_renderer_factory(info, impl, lock=registry_lock):
-    spec = info.name
-    reg = info.registry
-    package = info.package
-
-    isabs = os.path.isabs(spec)
-
-    if (not isabs) and (not ':' in spec) and package:
-        # relative resource spec
-        if not isabs:
-            pp = package_path(package)
-            spec = os.path.join(pp, spec)
-        spec = resource_spec_from_abspath(spec, package)
-    
-    if os.path.isabs(spec):
-        # 'spec' is an absolute filename
-        if not os.path.exists(spec):
-            raise ValueError('Missing template file: %s' % spec)
-        renderer = reg.queryUtility(ITemplateRenderer, name=spec)
-        if renderer is None:
-            renderer = impl(spec)
-            # cache the template
-            try:
-                lock.acquire()
-                reg.registerUtility(renderer, ITemplateRenderer, name=spec)
-            finally:
-                lock.release()
-    else:
-        # spec is a package:relpath resource spec
-        renderer = reg.queryUtility(ITemplateRenderer, name=spec)
-        if renderer is None:
-            try:
-                package_name, filename = spec.split(':', 1)
-            except ValueError: # pragma: no cover
-                # somehow we were passed a relative pathname; this
-                # should die
-                package_name = caller_package(4).__name__
-                filename = spec
-            abspath = pkg_resources.resource_filename(package_name, filename)
-            if not pkg_resources.resource_exists(package_name, filename):
-                raise ValueError(
-                    'Missing template resource: %s (%s)' % (spec, abspath))
-            renderer = impl(abspath)
-            settings = info.settings
-            if settings and not settings.get('reload_resources'):
+class ChameleonRendererLookup(object):
+    implements(IChameleonLookup)
+    def __init__(self, impl, registry):
+        self.impl = impl
+        self.registry = registry
+        self.lock = threading.Lock()
+        
+    def get_spec(self, name, package):
+        spec = name
+        isabs = os.path.isabs(name)
+
+        if (not isabs) and (not ':' in name) and package:
+            # relative resource spec
+            if not isabs:
+                pp = package_path(package)
+                spec = os.path.join(pp, spec)
+            spec = resource_spec_from_abspath(spec, package)
+        return spec
+
+    @reify # wait until completely necessary to look up translator
+    def translate(self):
+        return self.registry.queryUtility(IChameleonTranslate)
+
+    @reify # wait until completely necessary to look up debug_templates
+    def debug(self):
+        settings = self.registry.settings or {}
+        return settings.get('debug_templates', False)
+
+    @reify # wait until completely necessary to look up reload_templates
+    def auto_reload(self):
+        settings = self.registry.settings or {}
+        return settings.get('reload_templates', False)
+
+    def __call__(self, info):
+        spec = self.get_spec(info.name, info.package)
+        registry = info.registry
+
+        if os.path.isabs(spec):
+            # 'spec' is an absolute filename
+            if not os.path.exists(spec):
+                raise ValueError('Missing template file: %s' % spec)
+            renderer = registry.queryUtility(ITemplateRenderer, name=spec)
+            if renderer is None:
+                renderer = self.impl(spec, self)
                 # cache the template
                 try:
-                    lock.acquire()
-                    reg.registerUtility(renderer, ITemplateRenderer, name=spec)
+                    self.lock.acquire()
+                    registry.registerUtility(renderer,
+                                             ITemplateRenderer, name=spec)
                 finally:
-                    lock.release()
-        
-    return renderer
+                    self.lock.release()
+        else:
+            # spec is a package:relpath resource spec
+            renderer = registry.queryUtility(ITemplateRenderer, name=spec)
+            if renderer is None:
+                try:
+                    package_name, filename = spec.split(':', 1)
+                except ValueError: # pragma: no cover
+                    # somehow we were passed a relative pathname; this
+                    # should die
+                    package_name = caller_package(4).__name__
+                    filename = spec
+                abspath = pkg_resources.resource_filename(package_name,
+                                                          filename)
+                if not pkg_resources.resource_exists(package_name, filename):
+                    raise ValueError(
+                        'Missing template resource: %s (%s)' % (spec, abspath))
+                renderer = self.impl(abspath, self)
+                settings = info.settings or {}
+                if not settings.get('reload_resources'):
+                    # cache the template
+                    self.lock.acquire()
+                    try:
+                        registry.registerUtility(renderer, ITemplateRenderer,
+                                                 name=spec)
+                    finally:
+                        self.lock.release()
+
+        return renderer
+
+registry_lock = threading.Lock()
 
-def renderer_from_name(path, package=None): # XXX deprecate?
+def template_renderer_factory(info, impl, lock=registry_lock):
+    registry = info.registry
+    lookup = registry.queryUtility(IChameleonLookup, name=info.type)
+    if lookup is None:
+        lookup = ChameleonRendererLookup(impl, registry)
+        lock.acquire()
+        try:
+            registry.registerUtility(lookup, IChameleonLookup, name=info.type)
+        finally:
+            lock.release()
+    return lookup(info)
+
+# XXX deprecate
+def renderer_from_name(path, package=None): 
     return RendererHelper(name=path, package=package).renderer
 
 class RendererHelper(object):
diff --git a/pyramid/tests/test_chameleon_text.py b/pyramid/tests/test_chameleon_text.py
index 764124502..a42b92bfa 100644
--- a/pyramid/tests/test_chameleon_text.py
+++ b/pyramid/tests/test_chameleon_text.py
@@ -50,7 +50,8 @@ class TextTemplateRendererTests(Base, unittest.TestCase):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ITemplateRenderer
         path = self._getTemplatePath('minimal.txt')
-        verifyObject(ITemplateRenderer, self._makeOne(path))
+        lookup = DummyLookup()
+        verifyObject(ITemplateRenderer, self._makeOne(path, lookup))
 
     def test_class_implements_ITemplate(self):
         from zope.interface.verify import verifyClass
@@ -59,69 +60,73 @@ class TextTemplateRendererTests(Base, unittest.TestCase):
 
     def test_template_reified(self):
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template, instance.__dict__['template'])
 
     def test_template_with_ichameleon_translate(self):
-        from pyramid.interfaces import IChameleonTranslate
-        def ct(): pass
-        self.config.registry.registerUtility(ct, IChameleonTranslate)
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
-        self.assertEqual(template.translate, ct)
+        self.assertEqual(template.translate, lookup.translate)
 
     def test_template_with_debug_templates(self):
-        self.config.add_settings({'debug_templates':True})
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.debug = True
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.debug, True)
 
     def test_template_with_reload_templates(self):
-        self.config.add_settings({'reload_templates':True})
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.auto_reload = True
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.auto_reload, True)
 
-    def test_template_with_emptydict(self):
-        from pyramid.interfaces import ISettings
-        self.config.registry.registerUtility({}, ISettings)
+    def test_template_without_reload_templates(self):
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.auto_reload = False
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.auto_reload, False)
-        self.assertEqual(template.debug, False)
 
     def test_call(self):
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         result = instance({}, {})
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, 'Hello.\n')
 
     def test_call_with_nondict_value(self):
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.assertRaises(ValueError, instance, None, {})
 
     def test_call_nonminimal(self):
         nonminimal = self._getTemplatePath('nonminimal.txt')
-        instance = self._makeOne(nonminimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(nonminimal, lookup)
         result = instance({'name':'Chris'}, {})
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, 'Hello, Chris!\n')
 
     def test_implementation(self):
         minimal = self._getTemplatePath('minimal.txt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         result = instance.implementation()()
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, 'Hello.\n')
@@ -196,3 +201,8 @@ class GetTemplateTests(Base, unittest.TestCase):
         result = self._callFUT('foo')
         self.failUnless(result is renderer.template)
 
+class DummyLookup(object):
+    auto_reload=True
+    debug = True
+    def translate(self, msg): pass
+    
diff --git a/pyramid/tests/test_chameleon_zpt.py b/pyramid/tests/test_chameleon_zpt.py
index a969bac00..8f0b3f03c 100644
--- a/pyramid/tests/test_chameleon_zpt.py
+++ b/pyramid/tests/test_chameleon_zpt.py
@@ -43,7 +43,8 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
         from zope.interface.verify import verifyObject
         from pyramid.interfaces import ITemplateRenderer
         path = self._getTemplatePath('minimal.pt')
-        verifyObject(ITemplateRenderer, self._makeOne(path))
+        lookup = DummyLookup()
+        verifyObject(ITemplateRenderer, self._makeOne(path, lookup))
 
     def test_class_implements_ITemplate(self):
         from zope.interface.verify import verifyClass
@@ -52,7 +53,8 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
 
     def test_call(self):
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         result = instance({}, {})
         self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
@@ -60,55 +62,66 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase):
 
     def test_template_reified(self):
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template, instance.__dict__['template'])
 
     def test_template_with_ichameleon_translate(self):
-        from pyramid.interfaces import IChameleonTranslate
-        def ct(): pass
-        self.config.registry.registerUtility(ct, IChameleonTranslate)
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
-        self.assertEqual(template.translate, ct)
+        self.assertEqual(template.translate, lookup.translate)
 
     def test_template_with_debug_templates(self):
-        self.config.add_settings({'debug_templates':True})
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.debug = True
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.debug, True)
 
+    def test_template_without_debug_templates(self):
+        minimal = self._getTemplatePath('minimal.pt')
+        lookup = DummyLookup()
+        lookup.debug = False
+        instance = self._makeOne(minimal, lookup)
+        self.failIf('template' in instance.__dict__)
+        template  = instance.template
+        self.assertEqual(template.debug, False)
+
     def test_template_with_reload_templates(self):
-        self.config.add_settings({'reload_templates':True})
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.auto_reload = True
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.auto_reload, True)
 
-    def test_template_with_emptydict(self):
-        from pyramid.interfaces import ISettings
-        self.config.registry.registerUtility({}, ISettings)
+    def test_template_without_reload_templates(self):
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        lookup.auto_reload = False
+        instance = self._makeOne(minimal, lookup)
         self.failIf('template' in instance.__dict__)
         template  = instance.template
         self.assertEqual(template.auto_reload, False)
-        self.assertEqual(template.debug, False)
 
     def test_call_with_nondict_value(self):
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         self.assertRaises(ValueError, instance, None, {})
 
     def test_implementation(self):
         minimal = self._getTemplatePath('minimal.pt')
-        instance = self._makeOne(minimal)
+        lookup = DummyLookup()
+        instance = self._makeOne(minimal, lookup)
         result = instance.implementation()()
         self.failUnless(isinstance(result, unicode))
         self.assertEqual(result,
@@ -192,3 +205,8 @@ class GetTemplateTests(Base, unittest.TestCase):
         self._registerUtility(rf, IRendererFactory, name='foo')
         result = self._callFUT('foo')
         self.failUnless(result is renderer.template)
+
+class DummyLookup(object):
+    auto_reload=True
+    debug = True
+    def translate(self, msg): pass
diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py
index b4a6892db..1dab39a6e 100644
--- a/pyramid/tests/test_renderers.py
+++ b/pyramid/tests/test_renderers.py
@@ -23,6 +23,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         self.assertRaises(ValueError, self._callFUT, info, None)
 
@@ -37,6 +38,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         result = self._callFUT(info, None)
         self.failUnless(result is renderer)
@@ -52,6 +54,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         result = self._callFUT(info, None)
         self.failUnless(result is renderer)
@@ -66,6 +69,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         result = self._callFUT(info, None)
         self.failUnless(renderer is result)
@@ -82,6 +86,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':pyramid.tests,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         result = self._callFUT(info, None)
         self.failUnless(renderer is result)
@@ -93,6 +98,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         self.assertRaises(ValueError, self._callFUT, info, None)
 
@@ -107,6 +113,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         renderer = {}
         testing.registerUtility(renderer, ITemplateRenderer, name=spec)
@@ -126,6 +133,7 @@ class TestTemplateRendererFactory(unittest.TestCase):
             'package':None,
             'registry':self.config.registry,
             'settings':{},
+            'type':'type',
             })
         result = self._callFUT(info, factory)
         self.failUnless(result is renderer)
@@ -137,7 +145,6 @@ class TestTemplateRendererFactory(unittest.TestCase):
 
     def test_reload_resources_true(self):
         import pyramid.tests
-        from pyramid.threadlocal import get_current_registry
         from pyramid.interfaces import ISettings
         from pyramid.interfaces import ITemplateRenderer
         settings = {'reload_resources':True}
@@ -145,43 +152,44 @@ class TestTemplateRendererFactory(unittest.TestCase):
         renderer = {}
         factory = DummyFactory(renderer)
         spec = 'test_renderers.py'
+        reg = self.config.registry
         info = DummyRendererInfo({
             'name':spec,
             'package':pyramid.tests,
-            'registry':self.config.registry,
-            'settings':{},
+            'registry':reg,
+            'settings':settings,
+            'type':'type',
             })
         result = self._callFUT(info, factory)
         self.failUnless(result is renderer)
         spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py')
-        reg = get_current_registry()
         self.assertEqual(reg.queryUtility(ITemplateRenderer, name=spec),
                          None)
 
     def test_reload_resources_false(self):
         import pyramid.tests
-        from pyramid.threadlocal import get_current_registry
         from pyramid.interfaces import ITemplateRenderer
         settings = {'reload_resources':False}
         renderer = {}
         factory = DummyFactory(renderer)
         spec = 'test_renderers.py'
+        reg = self.config.registry
         info = DummyRendererInfo({
             'name':spec,
             'package':pyramid.tests,
-            'registry':self.config.registry,
+            'registry':reg,
             'settings':settings,
+            'type':'type',
             })
         result = self._callFUT(info, factory)
         self.failUnless(result is renderer)
         spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py')
-        reg = get_current_registry()
         self.assertNotEqual(reg.queryUtility(ITemplateRenderer, name=spec),
                             None)
 
 class TestRendererFromName(unittest.TestCase):
     def setUp(self):
-        cleanUp()
+        self.config = cleanUp()
 
     def tearDown(self):
         cleanUp()
@@ -191,8 +199,7 @@ class TestRendererFromName(unittest.TestCase):
         return renderer_from_name(path, package)
 
     def test_it(self):
-        from pyramid.threadlocal import get_current_registry
-        registry = get_current_registry()
+        registry = self.config.registry
         settings = {}
         registry.settings = settings
         from pyramid.interfaces import IRendererFactory
@@ -211,8 +218,7 @@ class TestRendererFromName(unittest.TestCase):
 
     def test_it_with_package(self):
         import pyramid
-        from pyramid.threadlocal import get_current_registry
-        registry = get_current_registry()
+        registry = self.config.registry
         settings = {}
         registry.settings = settings
         from pyramid.interfaces import IRendererFactory
@@ -534,7 +540,7 @@ class DummyFactory:
     def __init__(self, renderer):
         self.renderer = renderer
 
-    def __call__(self, path, **kw):
+    def __call__(self, path, lookup, **kw):
         self.path = path
         self.kw = kw
         return self.renderer