Add a new Params section to factories.

This handles parameters that alter the declarations of a factory.

A few technical notes:
- A parameter's outcome may alter other parameters
- In order to fix that, we perform a (simple) cyclic definition
  detection at class declaration time.
- Parameters may only be either naked values or ComplexParameter
  subclasses
- Parameters are never passed to the underlying class

2 files changed, 33 insertions, 101 deletions

diff --git a/tests/test_containers.py b/tests/test_containers.py
index 20c773a..a308353 100644
--- a/tests/test_containers.py
+++ b/tests/test_containers.py
@@ -103,97 +103,56 @@ class LazyStubTestCase(unittest.TestCase):
 
 
 class AttributeBuilderTestCase(unittest.TestCase):
-    def test_empty(self):
-        """Tests building attributes from an empty definition."""
+
+    def make_fake_factory(self, decls):
+        class Meta:
+            declarations = decls
+            parameters = {}
+            parameters_dependencies = {}
 
         class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                return extra
+            _meta = Meta
 
             @classmethod
             def _generate_next_sequence(cls):
                 return 1
 
+        return FakeFactory
+
+    def test_empty(self):
+        """Tests building attributes from an empty definition."""
+
+        FakeFactory = self.make_fake_factory({})
         ab = containers.AttributeBuilder(FakeFactory)
 
         self.assertEqual({}, ab.build(create=False))
 
     def test_factory_defined(self):
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
-
+        FakeFactory = self.make_fake_factory({'one': 1})
         ab = containers.AttributeBuilder(FakeFactory)
+
         self.assertEqual({'one': 1}, ab.build(create=False))
 
     def test_extended(self):
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
-
+        FakeFactory = self.make_fake_factory({'one': 1})
         ab = containers.AttributeBuilder(FakeFactory, {'two': 2})
         self.assertEqual({'one': 1, 'two': 2}, ab.build(create=False))
 
     def test_overridden(self):
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
-
+        FakeFactory = self.make_fake_factory({'one': 1})
         ab = containers.AttributeBuilder(FakeFactory, {'one': 2})
         self.assertEqual({'one': 2}, ab.build(create=False))
 
     def test_factory_defined_sequence(self):
         seq = declarations.Sequence(lambda n: 'xx%d' % n)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': seq}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
+        FakeFactory = self.make_fake_factory({'one': seq})
 
         ab = containers.AttributeBuilder(FakeFactory)
         self.assertEqual({'one': 'xx1'}, ab.build(create=False))
 
     def test_additionnal_sequence(self):
         seq = declarations.Sequence(lambda n: 'xx%d' % n)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
+        FakeFactory = self.make_fake_factory({'one': 1})
 
         ab = containers.AttributeBuilder(FakeFactory, extra={'two': seq})
         self.assertEqual({'one': 1, 'two': 'xx1'}, ab.build(create=False))
@@ -201,34 +160,14 @@ class AttributeBuilderTestCase(unittest.TestCase):
     def test_replaced_sequence(self):
         seq = declarations.Sequence(lambda n: 'xx%d' % n)
         seq2 = declarations.Sequence(lambda n: 'yy%d' % n)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': seq}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
+        FakeFactory = self.make_fake_factory({'one': seq})
 
         ab = containers.AttributeBuilder(FakeFactory, extra={'one': seq2})
         self.assertEqual({'one': 'yy1'}, ab.build(create=False))
 
     def test_lazy_function(self):
         lf = declarations.LazyFunction(int)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1, 'two': lf}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
+        FakeFactory = self.make_fake_factory({'one': 1, 'two': lf})
 
         ab = containers.AttributeBuilder(FakeFactory)
         self.assertEqual({'one': 1, 'two': 0}, ab.build(create=False))
@@ -241,17 +180,7 @@ class AttributeBuilderTestCase(unittest.TestCase):
 
     def test_lazy_attribute(self):
         la = declarations.LazyAttribute(lambda a: a.one * 2)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': 1, 'two': la}
-                d.update(extra)
-                return d
-
-            @classmethod
-            def _generate_next_sequence(cls):
-                return 1
+        FakeFactory = self.make_fake_factory({'one': 1, 'two': la})
 
         ab = containers.AttributeBuilder(FakeFactory)
         self.assertEqual({'one': 1, 'two': 2}, ab.build(create=False))
@@ -267,18 +196,12 @@ class AttributeBuilderTestCase(unittest.TestCase):
             pass
 
         sf = declarations.SubFactory(FakeInnerFactory)
-
-        class FakeFactory(object):
-            @classmethod
-            def declarations(cls, extra):
-                d = {'one': sf, 'two': 2}
-                d.update(extra)
-                return d
+        FakeFactory = self.make_fake_factory({'one': sf, 'two': 2})
 
         ab = containers.AttributeBuilder(FakeFactory, {'one__blah': 1, 'two__bar': 2})
         self.assertTrue(ab.has_subfields(sf))
         self.assertEqual(['one'], list(ab._subfields.keys()))
-        self.assertEqual(2, ab._attrs['two__bar'])
+        self.assertEqual(2, ab._declarations['two__bar'])
 
     def test_sub_factory(self):
         pass
diff --git a/tests/test_using.py b/tests/test_using.py
index 3ef5403..67db3bc 100644
--- a/tests/test_using.py
+++ b/tests/test_using.py
@@ -40,6 +40,15 @@ class TestObject(object):
         self.four = four
         self.five = five
 
+    def as_dict(self):
+        return dict(
+            one=self.one,
+            two=self.two,
+            three=self.three,
+            four=self.four,
+            five=self.five,
+        )
+
 
 class FakeModel(object):
     @classmethod