Get rid of get_options.

Shuffle Configurator around so that not passing a registry makes a default one.

4 files changed, 129 insertions, 119 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index 8d7dfa9da..a60e2aaa0 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -21,6 +21,10 @@ Internals
 
 - The ``repoze.bfg.view.renderer_from_name`` callable has been removed.
 
+- The ``repoze.bfg.settings.get_options`` callable has been removed.
+  Its job has been subsumed by the ``repoze.bfg.settings.Settings``
+  class constructor.
+
 Backwards Incompatibilites
 --------------------------
 
diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py
index 9c2765c7c..74c848946 100644
--- a/repoze/bfg/configuration.py
+++ b/repoze/bfg/configuration.py
@@ -42,10 +42,10 @@ from repoze.bfg.compat import all
 from repoze.bfg.exceptions import Forbidden
 from repoze.bfg.exceptions import NotFound
 from repoze.bfg.log import make_stream_logger
+from repoze.bfg.registry import Registry
 from repoze.bfg.request import route_request_iface
 from repoze.bfg.resource import PackageOverrides
 from repoze.bfg.settings import Settings
-from repoze.bfg.settings import get_options
 from repoze.bfg.settings import get_settings
 from repoze.bfg.static import StaticRootFactory
 from repoze.bfg.threadlocal import get_current_registry
@@ -77,21 +77,30 @@ def zcml_configure(name, package):
 
 class Configurator(object):
     """ A wrapper around the registry that performs configuration tasks """
-    def __init__(self, registry, defaults=False):
+    def __init__(self, registry=None):
+        if registry is None:
+            registry = self.make_default_registry()
         self.reg = registry
-        defaults and self.defaults()
 
-    def defaults(self):
+    def make_default_registry(self):
+        self.reg = Registry()
         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.root_factory(DefaultRootFactory)
+        self.debug_logger(None)
+        return self.reg
 
     def default_configuration(self, root_factory, package=None,
                               filename='configure.zcml', settings=None,
                               debug_logger=None, manager=manager, os=os,
                               lock=threading.Lock()):
 
+        self.make_default_registry()
+
         # registry, debug_logger, manager, os and lock *only* for unittests
         if settings is None:
             settings = {}
@@ -99,7 +108,7 @@ class Configurator(object):
         if not 'configure_zcml' in settings:
             settings['configure_zcml'] = filename
 
-        settings = Settings(get_options(settings))
+        settings = Settings(settings)
         filename = settings['configure_zcml']
 
         # not os.path.isabs below for windows systems
@@ -111,7 +120,6 @@ class Configurator(object):
         self.settings(settings)
         self.debug_logger(debug_logger)
         self.root_factory(root_factory or DefaultRootFactory)
-        self.defaults()
 
         # We push our ZCML-defined configuration into an app-local
         # component registry in order to allow more than one bfg app to live
diff --git a/repoze/bfg/settings.py b/repoze/bfg/settings.py
index 57295fcdc..e9a03ad0b 100644
--- a/repoze/bfg/settings.py
+++ b/repoze/bfg/settings.py
@@ -6,7 +6,45 @@ from zope.interface import implements
 from repoze.bfg.interfaces import ISettings
 
 class Settings(dict):
+    """ Deployment settings.  Update application settings (usually
+    from PasteDeploy keywords) with framework-specific key/value pairs
+    (e.g. find 'BFG_DEBUG_AUTHORIZATION' in os.environ and jam into
+    keyword args)."""
     implements(ISettings)
+    # _environ_ is dep inj for testing
+    def __init__(self, d=None, _environ_=os.environ, **kw):
+        if d is None:
+            d = {}
+        dict.__init__(self, d, **kw)
+        eget = _environ_.get
+        config_debug_all = self.get('debug_all', '')
+        eff_debug_all = asbool(eget('BFG_DEBUG_ALL', config_debug_all))
+        config_reload_all = self.get('reload_all', '')
+        eff_reload_all = asbool(eget('BFG_RELOAD_ALL',config_reload_all))
+        config_debug_auth = self.get('debug_authorization', '')
+        eff_debug_auth = asbool(eget('BFG_DEBUG_AUTHORIZATION',
+                                     config_debug_auth))
+        config_debug_notfound = self.get('debug_notfound', '')
+        eff_debug_notfound = asbool(eget('BFG_DEBUG_NOTFOUND',
+                                         config_debug_notfound))
+        config_reload_templates = self.get('reload_templates', '')
+        eff_reload_templates = asbool(eget('BFG_RELOAD_TEMPLATES',
+                                           config_reload_templates))
+        config_reload_resources = self.get('reload_resources', '')
+        eff_reload_resources = asbool(eget('BFG_RELOAD_RESOURCES',
+                                           config_reload_resources))
+        configure_zcml = self.get('configure_zcml', '')
+        eff_configure_zcml = eget('BFG_CONFIGURE_ZCML', configure_zcml)
+        update = {
+            'debug_authorization': eff_debug_all or eff_debug_auth,
+            'debug_notfound': eff_debug_all or eff_debug_notfound,
+            'reload_templates': eff_reload_all or eff_reload_templates,
+            'reload_resources':eff_reload_all or eff_reload_resources,
+            'configure_zcml':eff_configure_zcml,
+            }
+
+        self.update(update)
+        
     def __getattr__(self, name):
         # backwards compatibility
         try:
@@ -30,41 +68,3 @@ def asbool(s):
     s = str(s).strip()
     return s.lower() in ('t', 'true', 'y', 'yes', 'on', '1')
 
-def get_options(kw, environ=os.environ):
-    """ Update PasteDeploy application settings keywords with
-    framework-specific key/value pairs (e.g. find
-    'BFG_DEBUG_AUTHORIZATION' in os.environ and jam into keyword
-    args)."""
-    # environ is passed in for unit tests
-    eget = environ.get
-    config_debug_all = kw.get('debug_all', '')
-    effective_debug_all = asbool(eget('BFG_DEBUG_ALL',
-                                      config_debug_all))
-    config_reload_all = kw.get('reload_all', '')
-    effective_reload_all = asbool(eget('BFG_RELOAD_ALL',
-                                      config_reload_all))
-    config_debug_auth = kw.get('debug_authorization', '')
-    effective_debug_auth = asbool(eget('BFG_DEBUG_AUTHORIZATION',
-                                       config_debug_auth))
-    config_debug_notfound = kw.get('debug_notfound', '')
-    effective_debug_notfound = asbool(eget('BFG_DEBUG_NOTFOUND',
-                                           config_debug_notfound))
-    config_reload_templates = kw.get('reload_templates', '')
-    effective_reload_templates = asbool(eget('BFG_RELOAD_TEMPLATES',
-                                        config_reload_templates))
-    config_reload_resources = kw.get('reload_resources', '')
-    effective_reload_resources = asbool(eget('BFG_RELOAD_RESOURCES',
-                                             config_reload_resources))
-    configure_zcml = kw.get('configure_zcml', '')
-    effective_configure_zcml = eget('BFG_CONFIGURE_ZCML', configure_zcml)
-    update = {
-        'debug_authorization': effective_debug_all or effective_debug_auth,
-        'debug_notfound': effective_debug_all or effective_debug_notfound,
-        'reload_templates': effective_reload_all or effective_reload_templates,
-        'reload_resources':effective_reload_all or effective_reload_resources,
-        'configure_zcml':effective_configure_zcml,
-        }
-
-    kw.update(update)
-    return kw
-
diff --git a/repoze/bfg/tests/test_settings.py b/repoze/bfg/tests/test_settings.py
index ba43fac04..faa1f924f 100644
--- a/repoze/bfg/tests/test_settings.py
+++ b/repoze/bfg/tests/test_settings.py
@@ -6,161 +6,159 @@ class TestSettings(unittest.TestCase):
         from repoze.bfg.settings import Settings
         return Settings
 
-    def _makeOne(self, **options):
+    def _makeOne(self, d=None, environ=None):
+        if d is None:
+            d = {}
+        if environ is None:
+            environ = {}
         klass = self._getTargetClass()
-        return klass(options)
+        return klass(d, _environ_=environ)
 
     def test_getattr(self):
-        settings = self._makeOne(reload_templates=False)
+        settings = self._makeOne({'reload_templates':False})
         self.assertEqual(settings.reload_templates, False)
 
     def test_getattr_raises_attribute_error(self):
         settings = self._makeOne()
-        self.assertRaises(AttributeError, settings.__getattr__,
-                          'reload_templates'
-                          )
-
-class TestGetSettings(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-        
-    def _callFUT(self):
-        from repoze.bfg.settings import get_settings
-        return get_settings()
-
-    def test_it_nosettings(self):
-        self.assertEqual(self._callFUT(), None)
-
-    def test_it_withsettings(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import ISettings
-        sm = getSiteManager()
-        settings = {'a':1}
-        sm.registerUtility(settings, ISettings)
-        self.assertEqual(self._callFUT(), settings)
-
-class TestGetOptions(unittest.TestCase):
-    def _callFUT(self, *arg, **kw):
-        from repoze.bfg.settings import get_options
-        return get_options(*arg, **kw)
+        self.assertRaises(AttributeError, settings.__getattr__, 'mykey')
 
     def test_reload_templates(self):
-        result = self._callFUT({})
-        self.assertEqual(result['reload_templates'], False)
-        result = self._callFUT({'reload_templates':'false'})
+        settings = self._makeOne({})
+        self.assertEqual(settings['reload_templates'], False)
+        result = self._makeOne({'reload_templates':'false'})
         self.assertEqual(result['reload_templates'], False)
-        result = self._callFUT({'reload_templates':'t'})
+        result = self._makeOne({'reload_templates':'t'})
         self.assertEqual(result['reload_templates'], True)
-        result = self._callFUT({'reload_templates':'1'})
+        result = self._makeOne({'reload_templates':'1'})
         self.assertEqual(result['reload_templates'], True)
-        result = self._callFUT({}, {'BFG_RELOAD_TEMPLATES':'1'})
+        result = self._makeOne({}, {'BFG_RELOAD_TEMPLATES':'1'})
         self.assertEqual(result['reload_templates'], True)
-        result = self._callFUT({'reload_templates':'false'},
+        result = self._makeOne({'reload_templates':'false'},
                              {'BFG_RELOAD_TEMPLATES':'1'})
         self.assertEqual(result['reload_templates'], True)
 
     def test_reload_resources(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['reload_resources'], False)
-        result = self._callFUT({'reload_resources':'false'})
+        result = self._makeOne({'reload_resources':'false'})
         self.assertEqual(result['reload_resources'], False)
-        result = self._callFUT({'reload_resources':'t'})
+        result = self._makeOne({'reload_resources':'t'})
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({'reload_resources':'1'})
+        result = self._makeOne({'reload_resources':'1'})
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({}, {'BFG_RELOAD_RESOURCES':'1'})
+        result = self._makeOne({}, {'BFG_RELOAD_RESOURCES':'1'})
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({'reload_resources':'false'},
+        result = self._makeOne({'reload_resources':'false'},
                              {'BFG_RELOAD_RESOURCES':'1'})
         self.assertEqual(result['reload_resources'], True)
 
     def test_reload_all(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['reload_templates'], False)
         self.assertEqual(result['reload_resources'], False)
-        result = self._callFUT({'reload_all':'false'})
+        result = self._makeOne({'reload_all':'false'})
         self.assertEqual(result['reload_templates'], False)
         self.assertEqual(result['reload_resources'], False)
-        result = self._callFUT({'reload_all':'t'})
+        result = self._makeOne({'reload_all':'t'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({'reload_all':'1'})
+        result = self._makeOne({'reload_all':'1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({}, {'BFG_RELOAD_ALL':'1'})
+        result = self._makeOne({}, {'BFG_RELOAD_ALL':'1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
-        result = self._callFUT({'reload_all':'false'},
+        result = self._makeOne({'reload_all':'false'},
                              {'BFG_RELOAD_ALL':'1'})
         self.assertEqual(result['reload_templates'], True)
         self.assertEqual(result['reload_resources'], True)
 
     def test_debug_authorization(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['debug_authorization'], False)
-        result = self._callFUT({'debug_authorization':'false'})
+        result = self._makeOne({'debug_authorization':'false'})
         self.assertEqual(result['debug_authorization'], False)
-        result = self._callFUT({'debug_authorization':'t'})
+        result = self._makeOne({'debug_authorization':'t'})
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({'debug_authorization':'1'})
+        result = self._makeOne({'debug_authorization':'1'})
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({}, {'BFG_DEBUG_AUTHORIZATION':'1'})
+        result = self._makeOne({}, {'BFG_DEBUG_AUTHORIZATION':'1'})
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({'debug_authorization':'false'},
+        result = self._makeOne({'debug_authorization':'false'},
                              {'BFG_DEBUG_AUTHORIZATION':'1'})
         self.assertEqual(result['debug_authorization'], True)
 
     def test_debug_notfound(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['debug_notfound'], False)
-        result = self._callFUT({'debug_notfound':'false'})
+        result = self._makeOne({'debug_notfound':'false'})
         self.assertEqual(result['debug_notfound'], False)
-        result = self._callFUT({'debug_notfound':'t'})
+        result = self._makeOne({'debug_notfound':'t'})
         self.assertEqual(result['debug_notfound'], True)
-        result = self._callFUT({'debug_notfound':'1'})
+        result = self._makeOne({'debug_notfound':'1'})
         self.assertEqual(result['debug_notfound'], True)
-        result = self._callFUT({}, {'BFG_DEBUG_NOTFOUND':'1'})
+        result = self._makeOne({}, {'BFG_DEBUG_NOTFOUND':'1'})
         self.assertEqual(result['debug_notfound'], True)
-        result = self._callFUT({'debug_notfound':'false'},
+        result = self._makeOne({'debug_notfound':'false'},
                              {'BFG_DEBUG_NOTFOUND':'1'})
         self.assertEqual(result['debug_notfound'], True)
         
     def test_debug_all(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['debug_notfound'], False)
         self.assertEqual(result['debug_authorization'], False)
-        result = self._callFUT({'debug_all':'false'})
+        result = self._makeOne({'debug_all':'false'})
         self.assertEqual(result['debug_notfound'], False)
         self.assertEqual(result['debug_authorization'], False)
-        result = self._callFUT({'debug_all':'t'})
+        result = self._makeOne({'debug_all':'t'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({'debug_all':'1'})
+        result = self._makeOne({'debug_all':'1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({}, {'BFG_DEBUG_ALL':'1'})
+        result = self._makeOne({}, {'BFG_DEBUG_ALL':'1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_authorization'], True)
-        result = self._callFUT({'debug_all':'false'},
+        result = self._makeOne({'debug_all':'false'},
                              {'BFG_DEBUG_ALL':'1'})
         self.assertEqual(result['debug_notfound'], True)
         self.assertEqual(result['debug_authorization'], True)
 
     def test_configure_zcml(self):
-        result = self._callFUT({})
+        result = self._makeOne({})
         self.assertEqual(result['configure_zcml'], '')
-        result = self._callFUT({'configure_zcml':'abc'})
+        result = self._makeOne({'configure_zcml':'abc'})
         self.assertEqual(result['configure_zcml'], 'abc')
-        result = self._callFUT({}, {'BFG_CONFIGURE_ZCML':'abc'})
+        result = self._makeOne({}, {'BFG_CONFIGURE_ZCML':'abc'})
         self.assertEqual(result['configure_zcml'], 'abc')
-        result = self._callFUT({'configure_zcml':'def'},
+        result = self._makeOne({'configure_zcml':'def'},
                              {'BFG_CONFIGURE_ZCML':'abc'})
         self.assertEqual(result['configure_zcml'], 'abc')
 
     def test_originals_kept(self):
-        result = self._callFUT({'a':'i am so a'})
+        result = self._makeOne({'a':'i am so a'})
         self.assertEqual(result['a'], 'i am so a')
 
+
+class TestGetSettings(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
+    def _callFUT(self):
+        from repoze.bfg.settings import get_settings
+        return get_settings()
+
+    def test_it_nosettings(self):
+        self.assertEqual(self._callFUT(), None)
+
+    def test_it_withsettings(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import ISettings
+        sm = getSiteManager()
+        settings = {'a':1}
+        sm.registerUtility(settings, ISettings)
+        self.assertEqual(self._callFUT(), settings)
+