Merge lp:~ricardokirkner/configglue/declarative-syntax into lp:configglue

[Ricardo Kirkner]

fixes proper schema inheritance using declarative syntax

This branch fixes proper schema inheritance using declarative syntax.

For example:

class SchemaA(Schema):
    foo = ConfigSection()
    foo.bar = IntConfigOption()

class SchemaB(SchemaA):
    foo = deepcopy(SchemaA.foo)
    foo.baz = BoolConfigOption()

In this code, the SchemaB class would have a section called 'foo' with *two* options, 'bar' and 'baz'. When initializing the class instance, all attributes get merged so that they get correctly overridden by the subclass' attributes.

It's necessary to have the section duplicate, as not having it results in a syntax error. By merging sections together at initialization, the end effect is the desired one, however.

[lp:~ricardokirkner/configglue/declarative-syntax]

43. By Ricardo Kirkner on 2011-04-02

merged in latest trunk

44. By Ricardo Kirkner on 2011-04-02

only iterate once over the schema section/options

fix failing tests as a side-effect

[Łukasz Czyżykowski (lukasz-czyzykowski)]

Wouldn't it be easier to just merge resulting _sections dictionaries instead of digging out all the information from classes?

Something like:
 - run superclass's configuration definition code, which creates internal structures (_sections?),
 - run current class configuration definition code but save it to different structure,
 - merge resulting structures.

This should be simpler and require less usage of __class__ and __mro__ attributes.

[lp:~ricardokirkner/configglue/declarative-syntax]

45. By Ricardo Kirkner on 2011-04-09

simplified schema inheritance so that no magic is needed

removed merge method as this is no longer need (will be added as a separate
branch later)

documentation will be added in a separate branch

46. By Ricardo Kirkner on 2011-04-09

removed conditional as it's not needed

get_config_objects will only return objects of type ConfigSection or
ConfigOption, so _add_item will not receive objects of a different type.

[John Lenton (chipaca)]

\o/

review: Approve

=== modified file 'configglue/pyschema/schema.py'
--- configglue/pyschema/schema.py	2011-03-31 23:15:40 +0000
+++ configglue/pyschema/schema.py	2011-04-09 15:59:29 +0000
@@ -16,10 +16,10 @@
 ###############################################################################
 
 from copy import deepcopy
+from inspect import getmembers
 
 
 __all__ = [
-    'super_vars',
     'BoolConfigOption',
     'ConfigOption',
     'ConfigSection',
@@ -36,15 +36,10 @@
 _internal = object.__dict__.keys() + ['__module__']
 
 
-def super_vars(obj):
-    """An extended version of vars() that walks all base classes."""
-    items = {}
-    if hasattr(obj, '__mro__'):
-        bases = map(vars, obj.__mro__)
-        map(items.update, bases)
-    else:
-        items = vars(obj)
-    return items
+def get_config_objects(obj):
+    objects = ((n, o) for (n, o) in getmembers(obj)
+        if isinstance(o, (ConfigSection, ConfigOption)))
+    return objects
 
 
 class Schema(object):
@@ -65,45 +60,28 @@
     configuration files.
     """
 
-    def __new__(cls):
-        instance = super(Schema, cls).__new__(cls)
-
-        # override class attributes with instance attributes to correctly
-        # handle schema inheritance
-        schema_attributes = filter(
-            lambda x: x not in _internal and
-                isinstance(getattr(cls, x), (ConfigSection, ConfigOption)),
-            super_vars(cls))
-        for attr in schema_attributes:
-            setattr(instance, attr, deepcopy(getattr(cls, attr)))
-
-        return instance
-
     def __init__(self):
         self.includes = LinesConfigOption(item=StringConfigOption())
         self._sections = {}
         # add section and options to the schema
-        for key in super_vars(self.__class__):
-            value = getattr(self, key)
-            self._add_item(key, value)
+        for name, item in get_config_objects(self.__class__):
+            self._add_item(name, item)
 
     def _add_item(self, name, item):
         """Add a top-level item to the schema."""
-        if not isinstance(item, (ConfigSection, ConfigOption)):
-            return
-
         item.name = name
         if isinstance(item, ConfigSection):
             self._add_section(name, item)
         elif isinstance(item, ConfigOption):
             self._add_option(name, item)
+        # override class attributes with instance attributes to correctly
+        # handle schema inheritance
+        setattr(self, name, deepcopy(item))
 
     def _add_section(self, name, section):
         """Add a top-level section to the schema."""
         self._sections[name] = section
-        items = super_vars(section).items()
-        options = ((k, v) for (k, v) in items if isinstance(v, ConfigOption))
-        for opt_name, opt in options:
+        for opt_name, opt in get_config_objects(section):
             opt.name = opt_name
             opt.section = section
 
@@ -151,7 +129,8 @@
             for s in self.sections():
                 options += self.options(s)
         elif section.name == '__main__':
-            options = [getattr(self, att) for att in super_vars(self.__class__) 
+            class_config_objects = get_config_objects(self.__class__)
+            options = [getattr(self, att) for att, _ in class_config_objects
                            if isinstance(getattr(self, att), ConfigOption)]
         else:
             options = section.options()

=== modified file 'tests/pyschema/test_schema.py'
--- tests/pyschema/test_schema.py	2011-03-31 23:15:40 +0000
+++ tests/pyschema/test_schema.py	2011-04-09 15:59:29 +0000
@@ -17,6 +17,7 @@
 ###############################################################################
 
 import unittest
+from copy import deepcopy
 from StringIO import StringIO
 
 from configglue.pyschema.parser import SchemaConfigParser
@@ -154,6 +155,35 @@
         # test on the other schema
         self.assertFalse(hasattr(self.other.foo, 'baz'))
 
+    def test_merge_inherited(self):
+        class SchemaA(Schema):
+            foo = ConfigSection()
+            foo.bar = IntConfigOption()
+            bar = IntConfigOption()
+
+        class SchemaB(SchemaA):
+            foo = deepcopy(SchemaA.foo)
+            foo.baz = IntConfigOption()
+
+        # SchemaB inherits attributes from SchemaA and merges its own
+        # attributes into
+        schema = SchemaB()
+        section_names = set(s.name for s in schema.sections())
+        option_names = set(o.name for o in schema.options('__main__'))
+        foo_option_names = set(o.name for o in schema.options('foo'))
+        self.assertEqual(section_names, set(['__main__', 'foo']))
+        self.assertEqual(option_names, set(['bar']))
+        self.assertEqual(foo_option_names, set(['bar', 'baz']))
+
+        # SchemaB inheritance does not affect SchemaA
+        schema = SchemaA()
+        section_names = set(s.name for s in schema.sections())
+        option_names = set(o.name for o in schema.options('__main__'))
+        foo_option_names = set(o.name for o in schema.options('foo'))
+        self.assertEqual(section_names, set(['__main__', 'foo']))
+        self.assertEqual(option_names, set(['bar']))
+        self.assertEqual(foo_option_names, set(['bar']))
+
 
 class TestStringConfigOption(unittest.TestCase):
     def setUp(self):