Data objects

configurator/__init__.py

@@ -1,6 +1,7 @@
 from .config import Config
 from .merge import default_mergers
 from .mapping import source, target, convert, required, if_supplied, value
+from .proxy import Proxy
 
 __all__ = (
     'Config',

configurator/data.py

@@ -0,0 +1,7 @@
+class DataValue:
+
+    def __init__(self, value):
+        self.value = value
+
+    def get(self):
+        return self.value

configurator/mapping.py

@@ -1,15 +1,18 @@
-from .path import (
-    Path, parse_text, ConvertOp, RequiredOp, NotPresent, IfSuppliedOp, ValueOp
-)
+from .data import DataValue
+from .path import Path, parse_text, ConvertOp, RequiredOp, NotPresent, IfSuppliedOp, ValueOp
 
 
 def load(data, path):
     path = parse_text(path)
+    if isinstance(data, DataValue):
+        data = data.get()
     for op in path.ops:
         if isinstance(data, NotPresent):
             op.not_present(data)
         else:
             data = op.get(data)
+            if isinstance(data, DataValue):
+                data = data.get()
     return data
 
 

configurator/node.py

@@ -1,5 +1,6 @@
 from pprint import pformat
 
+from .data import DataValue
 from .path import parse_text, NotPresent
 
 
@@ -23,6 +24,8 @@ def __init__(self, data=None, container=None, accessor=None):
         self._accessor = accessor
 
     def _wrap(self, accessor, value):
+        if isinstance(value, DataValue):
+            value = value.get()
         if isinstance(value, (dict, list)):
             value = ConfigNode(value, self.data, accessor)
         return value
@@ -82,7 +85,7 @@ def get(self, name=None, default=None):
         for simple values.
         """
         if name is None:
-            return self.data
+            return self.data.get() if isinstance(self.data, DataValue) else self.data
         try:
             return self._get(name)
         except KeyError:
@@ -135,6 +138,8 @@ def node(self, path=None, create=False):
 
         data = self.data
         for op in path.ops:
+            if isinstance(data, DataValue):
+                data = data.get()
             if isinstance(data, NotPresent):
                 op.not_present(data)
             else:

configurator/proxy.py

@@ -0,0 +1,35 @@
+class Proxy:
+    """
+    A proxy is an object that can be passed around to present another object
+    that needs to be referenced during configuration parsing but cannot be used
+    until configuration parsing is completed.
+    """
+
+    _object = None
+
+    def __init__(self, name='proxy'):
+        self._name = name
+
+    def __deepcopy__(self, memo):
+        # Merging and cloning make use of deepcopy. Proxies should not be
+        # copied as part of this process, so this is disabled here:
+        return self
+
+    def set(self, obj):
+        self._object = obj
+
+    def get(self):
+        if self._object is None:
+            raise RuntimeError(f'Cannot use {self._name} before it is configured')
+        return self._object
+
+    def clone(self):
+        proxy = type(self)(self._name)
+        proxy.set(self._object)
+        return proxy
+
+    def __getattr__(self, item):
+        return getattr(self.get(), item)
+
+    def __call__(self, *args, **kw):
+        return self.__getattr__('__call__')(*args, **kw)

tests/test_data.py

@@ -0,0 +1,46 @@
+from testfixtures import compare, ShouldRaise, generator
+
+from configurator.data import DataValue
+from configurator.mapping import load, source
+from configurator.node import ConfigNode
+
+
+class TestDataValue:
+
+    def test_load_root(self):
+        compare(load(DataValue('foo'), source), expected='foo')
+
+    def test_load_nested(self):
+        compare(load([DataValue('foo')], source[0]), expected='foo')
+
+    def test_load_traverse_simple(self):
+        with ShouldRaise(TypeError('string indices must be integers')):
+            load(DataValue('foo'), source['foo'])
+
+    def test_load_traverse_container(self):
+        compare(load([DataValue({'bar': ['foo']})], source[0]['bar'][0]), expected='foo')
+
+    def test_item_get_container(self):
+        compare(ConfigNode({'a': DataValue({'b': 'c'})})['a'], expected=ConfigNode({'b': 'c'}))
+
+    def test_attr_get_simple(self):
+        compare(ConfigNode({'a': DataValue('b')}).a, expected='b')
+
+    def test_items(self):
+        compare(ConfigNode({'a': DataValue('b')}).items(), expected=generator(('a', 'b')))
+
+    def test_node_get(self):
+        compare(ConfigNode(DataValue('b')).get(), expected='b')
+
+    def test_node_get_name(self):
+        compare(ConfigNode({'a': DataValue('b')}).get('a'), expected='b')
+
+    def test_node_get_wrapped(self):
+        compare(ConfigNode(DataValue({'b': 'c'})).get(), expected={'b': 'c'})
+
+    def test_node_get_wrapped_name(self):
+        compare(ConfigNode({'a': DataValue({'b': 'c'})}).get('a'), expected=ConfigNode({'b': 'c'}))
+
+    def test_node_node_traverse(self):
+        node = ConfigNode({'b': DataValue({'c': {'d': 'e'}})})
+        compare(node.node('b.c.d').get(), expected='e')

tests/test_functional.py

@@ -1,10 +1,13 @@
 from argparse import ArgumentParser
 
-from testfixtures import compare
+from testfixtures import compare, ShouldRaise
 from configurator import Config
+from configurator.data import DataValue
 from configurator.mapping import target, convert
 import pytest
 
+from configurator.proxy import Proxy
+
 
 class TestFunctional(object):
 
@@ -87,6 +90,131 @@ def test_overlay(self, dir):
         compare(config.user, expected=2)
         compare(config.file, expected=3)
 
+    def test_lazy_load(self, dir):
+        yaml = pytest.importorskip("yaml")
+
+        class VaultClient:
+
+            def __init__(self, host, token):
+                self.host = host
+                self.token = token
+
+            def load(self, key):
+                return {'name': key.capitalize(), 'password': '...'}
+
+        class VaultValue(DataValue):
+
+            def __init__(self, client, key):
+                self.client = client
+                self.key = key
+
+            def get(self):
+                return self.client.load(self.key)
+
+        client_ = Proxy()
+
+        def parser(client):
+
+            class Loader(yaml.Loader):
+                pass
+
+            def value_from_yaml(loader, node):
+                return VaultValue(client, loader.construct_mapping(node)['key'])
+
+            Loader.add_constructor('!from_vault', value_from_yaml)
+
+            def parser_(path):
+                return yaml.load(path, Loader)
+
+            return parser_
+
+        parser_ = parser(client_)
+
+        path1 = dir.write('default.yml', '''
+            vault:
+              host: localhost
+              token: foo
+            users:
+            - !from_vault {key: someuser}
+        ''')
+
+        path2 = dir.write('testing.yml', '''
+            users:
+            - !from_vault {key: testuser}
+        ''')
+
+        default = Config.from_path(path1, parser=parser_)
+        testing = Config.from_path(path2, parser=parser_)
+
+        # confirm the proxy isn't configured at this point, and so the values can't
+        # be resolved without raising an exception:
+        with ShouldRaise(RuntimeError('Cannot use proxy before it is configured')):
+            default.users[0].name
+        with ShouldRaise(RuntimeError('Cannot use proxy before it is configured')):
+            testing.users[0].name
+
+        config = default + testing
+
+        client_.set(VaultClient(**config.vault.data))
+        compare(config.users[0].data, expected={'name': 'Someuser', 'password': '...'})
+
+        # make sure iteration works:
+        compare([user.name for user in config.users], expected=['Someuser', 'Testuser'])
+
+        # make sure clone still works:
+        config.clone()
+        compare(config.users.data[0], expected=VaultValue(client_, 'someuser'))
+
+    def test_change_proxy_after_clone(self):
+        user = Proxy()
+        config = Config({'user': user})
+        with ShouldRaise(RuntimeError('Cannot use proxy before it is configured')):
+            config.user.get()
+
+        config.set_proxy(user, 'a')
+        compare(config.user.get(), expected='a')
+
+        config_ = config.clone()
+        config_.set_proxy(user, 'b')
+
+        compare(config.user.get(), expected='a')
+        compare(config_.user.get(), expected='b')
+
+    def test_proxy_setting_with_merge(self):
+        db = Proxy()
+
+        class User(DataValue):
+
+            def __init__(self, db, name):
+                self.db = db
+                self.name = name
+
+            def get(self):
+                db_ = self.db.get()
+                return f'{self.name} from {db_}'
+
+        config1 = Config({'users': [User(db, 'a')]})
+        config2 = Config({'users': [User(db, 'b')]})
+
+        db.set(0)
+        compare(config1.users, expected=['a from 0'])
+        compare(config2.users, expected=['b from 0'])
+
+        config1.set_proxy(db, 1)
+        config2.set_proxy(db, 2)
+        compare(config1.users, expected=['a from 1'])
+        compare(config2.users, expected=['b from 2'])
+
+        config3 = config1 + config2
+        compare(config1.users, expected=['a from 1'])
+        compare(config2.users, expected=['b from 2'])
+        compare(config3.users, expected=['a from 1', 'b from 2'])
+
+        config3.set_proxy(db, 3)
+        compare(config1.users, expected=['a from 1'])
+        compare(config2.users, expected=['b from 2'])
+        compare(config3.users, expected=['a from 3', 'b from 3'])
+
 
 def test_fake_fs(fs):
     fs.create_file('/foo/bar.yml', contents='foo: 1\n')

tests/test_proxy.py

@@ -0,0 +1,43 @@
+from configurator.proxy import Proxy
+from testfixtures import ShouldRaise, compare
+from testfixtures.mock import Mock
+
+
+def test_unnamed_unconfigured():
+    proxy = Proxy()
+    with ShouldRaise(RuntimeError('Cannot use proxy before it is configured')):
+        proxy.foo
+
+
+def test_named_unconfigured():
+    proxy = Proxy('My Foo')
+    with ShouldRaise(RuntimeError('Cannot use My Foo before it is configured')):
+        proxy.foo
+
+
+def test_configured_attr():
+    proxy = Proxy()
+    foo = Mock()
+    proxy.set(foo)
+    assert proxy.bar is foo.bar
+
+
+def test_configured_function():
+
+    def foo(n):
+        return n+1
+
+    proxy = Proxy()
+    proxy.set(foo)
+
+    compare(proxy(1), expected=2)
+
+
+def test_clone():
+    proxy = Proxy('foo')
+    proxy.set(1)
+    proxy_ = proxy.clone()
+    proxy_.set(2)
+    compare(proxy.get(), expected=1)
+    compare(proxy_.get(), expected=2)
+    compare(proxy_._name, expected='foo')