Ticket #14264: 14264.2.diff

django/conf/__init__.py

@@ -9 +9 @@
 import os
 import re
 import time     # Needed for Windows
+import types
 import warnings
 
 from django.conf import global_settings
@@ -49 +50 @@
         """
         if self._wrapped is not empty:
             raise RuntimeError('Settings already configured.')
-        holder = UserSettingsHolder(default_settings)
-        for name, value in options.items():
-            setattr(holder, name, value)
+        holder = UserSettingsHolder(default_settings=default_settings,
+                                    extra_settings=options)
         self._wrapped = holder
 
     @property
@@ -62 +62 @@
         return self._wrapped is not empty
 
 
-class BaseSettings(object):
+class Settings(object):
     """
     Common logic for settings whether set by a module or by the user.
     """
+
+    # Settings that should be converted into tuples if they're mistakenly
+    # entered as strings.
+    tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS")
+    # Flag to specify whether or not changes should be made to environment.
+    environ_changes_allowed = True
+
+    def __init__(self, settings_module=None, default_settings=global_settings,
+                 extra_settings=None):
+        if settings_module:
+            # store the settings module in case someone later cares
+            self.SETTINGS_MODULE = settings_module
+        self.initialize([default_settings, settings_module, extra_settings])
+        self.post_setup()
+
     def __setattr__(self, name, value):
         if name in ("MEDIA_URL", "STATIC_URL") and value and not value.endswith('/'):
             warnings.warn("If set, %s must end with a slash" % name,
@@ -75 +90 @@
                           "use STATIC_URL instead.", DeprecationWarning)
         object.__setattr__(self, name, value)
 
-
-class Settings(BaseSettings):
-    def __init__(self, settings_module):
-        # update this dict from global settings (but only for ALL_CAPS settings)
-        for setting in dir(global_settings):
-            if setting == setting.upper():
-                setattr(self, setting, getattr(global_settings, setting))
-
-        # store the settings module in case someone later cares
-        self.SETTINGS_MODULE = settings_module
-
-        try:
-            mod = importlib.import_module(self.SETTINGS_MODULE)
-        except ImportError, e:
-            raise ImportError("Could not import settings '%s' (Is it on sys.path?): %s" % (self.SETTINGS_MODULE, e))
-
-        # Settings that should be converted into tuples if they're mistakenly entered
-        # as strings.
-        tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS")
-
-        for setting in dir(mod):
-            if setting == setting.upper():
-                setting_value = getattr(mod, setting)
-                if setting in tuple_settings and type(setting_value) == str:
-                    setting_value = (setting_value,) # In case the user forgot the comma.
-                setattr(self, setting, setting_value)
-
-        # Expand entries in INSTALLED_APPS like "django.contrib.*" to a list
-        # of all those apps.
+    def initialize(self, settings_objs):
+        """
+        Initializes this settings object based on attributes/keys from the
+        objects in the settings_objs list.
+        """
+        for obj in settings_objs:
+            if not obj:
+                continue
+            for setting, value in dict_from_object(obj).iteritems():
+                    setattr(self, setting, value)
+
+    def post_setup(self):
+        self._correct_tuple_settings()
+        # Must remain after call to correct tuple settings, because
+        # INSTALLED_APPS is a tuple setting.
+        self._expand_installed_apps()
+        self._set_tz()
+        self._setup_logging()
+
+    def _expand_installed_apps(self):
+        """
+        Expand glob entries in INSTALLED_APPS, e.g. "django.contrib.*", to a
+        list of all those apps.
+        """
         new_installed_apps = []
         for app in self.INSTALLED_APPS:
             if app.endswith('.*'):
@@ -119 +129 @@
                 new_installed_apps.append(app)
         self.INSTALLED_APPS = new_installed_apps
 
+    def _correct_tuple_settings(self):
+        """
+        For settings that are meant to be tuples, auto correct if user forgot
+        trailing comma on a single value.
+        """
+        for setting in self.tuple_settings:
+            value = getattr(self, setting, None)
+            if isinstance(value, basestring):
+                setattr(self, setting, (value,))
+
+    def _set_tz(self):
+        if not self.environ_changes_allowed:
+            return
         if hasattr(time, 'tzset') and self.TIME_ZONE:
             # When we can, attempt to validate the timezone. If we can't find
             # this file, no check happens and it's harmless.
@@ -131 +154 @@
             os.environ['TZ'] = self.TIME_ZONE
             time.tzset()
 
+    def _setup_logging(self):
         # Settings are configured, so we can set up the logger if required
         if self.LOGGING_CONFIG:
             # First find the logging configuration function ...
@@ -145 +169 @@
             logging_config_func(self.LOGGING)
 
 
-class UserSettingsHolder(BaseSettings):
+class UserSettingsHolder(Settings):
     """
     Holder for user configured settings.
     """
     # SETTINGS_MODULE doesn't make much sense in the manually configured
     # (standalone) case.
     SETTINGS_MODULE = None
-
-    def __init__(self, default_settings):
-        """
-        Requests for configuration variables not in this class are satisfied
-        from the module specified in default_settings (if possible).
-        """
-        self.default_settings = default_settings
-
-    def __getattr__(self, name):
-        return getattr(self.default_settings, name)
-
-    def __dir__(self):
-        return self.__dict__.keys() + dir(self.default_settings)
-
-    # For Python < 2.6:
-    __members__ = property(lambda self: self.__dir__())
+    # Don't make any modifications to the process environment variables.
+    environ_changes_allowed = False
+
 
 settings = LazySettings()
 
 
+def import_module(name):
+    try:
+        mod = importlib.import_module(name)
+    except ImportError, e:
+        raise ImportError(
+            "Could not import settings '%s' (Is it on sys.path?): %s"
+            % (name, e))
+    return mod
+
+
+def dict_from_object(obj):
+    """
+    Return a dictionary of obj's attributes, where obj can be one of:
+
+    * A dictionary
+    * A string containing the name of a settings module
+    * A Settings instance
+    * A module
+
+    Only attributes/keys that are ALL CAPS are returned.
+    """
+    if isinstance(obj, basestring):
+        obj = import_module(obj)
+    if not isinstance(obj, dict):
+        obj = dict([(attr, getattr(obj, attr)) for attr in dir(obj)])
+
+    # Only keep attributes that are (ALL CAPS).
+    keep = lambda k: k == k.upper()
+    return dict([(k, v) for k, v in obj.iteritems() if keep(k)])
+
 
 def compat_patch_logging_config(logging_config):
     """

django/core/management/commands/diffsettings.py

@@ -1 +1 @@
 from django.core.management.base import NoArgsCommand
 
-def module_to_dict(module, omittable=lambda k: k.startswith('_')):
-    "Converts a module namespace to a Python dictionary. Used by get_settings_diff."
-    return dict([(k, repr(v)) for k, v in module.__dict__.items() if not omittable(k)])
 
 class Command(NoArgsCommand):
     help = """Displays differences between the current settings.py and Django's
@@ -13 +10 @@
 
     def handle_noargs(self, **options):
         # Inspired by Postfix's "postconf -n".
-        from django.conf import settings, global_settings
+        from django.conf import settings, global_settings, dict_from_object
 
         # Because settings are imported lazily, we need to explicitly load them.
         settings._setup()
 
-        user_settings = module_to_dict(settings._wrapped)
-        default_settings = module_to_dict(global_settings)
+        user_settings = dict_from_object(settings._wrapped)
+        default_settings = dict_from_object(global_settings)
 
         output = []
         keys = user_settings.keys()
         keys.sort()
         for key in keys:
             if key not in default_settings:
-                output.append("%s = %s  ###" % (key, user_settings[key]))
+                output.append("%s = %r  ###" % (key, user_settings[key]))
             elif user_settings[key] != default_settings[key]:
-                output.append("%s = %s" % (key, user_settings[key]))
+                output.append("%s = %r" % (key, user_settings[key]))
         return '\n'.join(output)

django/test/utils.py

@@ -221 +221 @@
         return inner
 
     def enable(self):
-        override = OverrideSettingsHolder(settings._wrapped)
-        for key, new_value in self.options.items():
-            setattr(override, key, new_value)
+        override = OverrideSettingsHolder(default_settings=settings._wrapped,
+                                          extra_settings=self.options)
         settings._wrapped = override
 
     def disable(self):

tests/regressiontests/app_loading/test_settings.py

@@ -1 +1 @@
 INSTALLED_APPS = (
     'parent.*',
 )
+
+TIME_ZONE='Europe/London'

tests/regressiontests/app_loading/tests.py

@@ -3 +3 @@
 import sys
 import time
 
-from django.conf import Settings
+from django.conf import Settings, LazySettings
 from django.db.models.loading import cache, load_app, get_model, get_models
 from django.utils.unittest import TestCase
 
 
-class InstalledAppsGlobbingTest(TestCase):
-    def setUp(self):
-        self.OLD_SYS_PATH = sys.path[:]
-        sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-        self.OLD_TZ = os.environ.get("TZ")
-
-    def test_globbing(self):
-        settings = Settings('test_settings')
-        self.assertEqual(settings.INSTALLED_APPS, ['parent.app', 'parent.app1', 'parent.app_2'])
-
-    def tearDown(self):
-        sys.path = self.OLD_SYS_PATH
-        if hasattr(time, "tzset") and self.OLD_TZ:
-            os.environ["TZ"] = self.OLD_TZ
-            time.tzset()
-
-
 class EggLoadingTest(TestCase):
 
     def setUp(self):
@@ -123 +106 @@
         self.assertEqual(
             set(NotInstalledModel._meta.get_all_field_names()),
             set(["id", "relatedmodel", "m2mrelatedmodel"]))
+
+
+class SettingsMixin(object):
+
+    def setUp(self):
+        self.OLD_SYS_PATH = sys.path[:]
+        sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+        self.OLD_TZ = os.environ.get("TZ")
+
+    def tearDown(self):
+        sys.path = self.OLD_SYS_PATH
+        if hasattr(time, "tzset") and self.OLD_TZ:
+            os.environ["TZ"] = self.OLD_TZ
+            time.tzset()
+
+
+class SettingsConfigureTest(SettingsMixin, TestCase):
+    """
+    Tests for settings using settings.configure().
+    """
+
+    def test_installed_app_globbing(self):
+        settings = LazySettings()
+        settings.configure(INSTALLED_APPS=('parent.*',))
+        self.assertEqual(settings.INSTALLED_APPS, ['parent.app', 'parent.app1', 'parent.app_2'])
+
+    def test_tuple_settings(self):
+        settings = LazySettings()
+        settings.configure(INSTALLED_APPS="parent.app", TEMPLATE_DIRS="foo")
+        self.assertEqual(settings.INSTALLED_APPS, ['parent.app'])
+        self.assertEqual(settings.TEMPLATE_DIRS, ('foo',))
+
+    def test_time_zone_environ(self):
+        """
+        Time zone environment variable shouldn't get altered.
+        """
+        orig_tz = os.environ.get('TZ')
+        settings = LazySettings()
+        settings.configure(TIME_ZONE='Europe/London')
+        # Time zone updated, but not environment variable.
+        self.assertEqual(settings.TIME_ZONE, 'Europe/London')
+        self.assertEqual(os.environ.get('TZ'), orig_tz)
+
+
+class SettingsTest(SettingsMixin, TestCase):
+    """
+    Tests for settings using Settings object.
+    """
+
+    def test_installed_app_globbing(self):
+        settings = Settings('test_settings')
+        self.assertEqual(settings.INSTALLED_APPS, ['parent.app', 'parent.app1', 'parent.app_2'])
+
+    def test_tuple_settings(self):
+        settings = Settings('tuple_settings')
+        self.assertEqual(settings.INSTALLED_APPS, ['parent.app'])
+        self.assertEqual(settings.TEMPLATE_DIRS, ('foo',))
+
+    def test_time_zone_environ(self):
+        """
+        Time zone environment variable shouldn't get altered.
+        """
+        orig_tz = os.environ.get('TZ')
+        settings = Settings('test_settings')
+        self.assertEqual(settings.TIME_ZONE, 'Europe/London')
+        self.assertEqual(os.environ.get('TZ'), 'Europe/London')

tests/regressiontests/app_loading/tuple_settings.py

@@ +1 @@
+# Settings file for testing correction of tuple settings.
+INSTALLED_APPS="parent.app"
+TEMPLATE_DIRS="foo"