First implementation of the context mapping passed to resolve and build.

Author: MrUPGrade

.flake8

@@ -1,2 +1,3 @@
 [flake8]
 ignore = E501, E402
+exclude = docs

pyioc/containers.py

@@ -34,12 +34,7 @@ class InstanceLifetime(Enum):
     """
     New instance will be created every time container will be ask for object on given key.
     """
-    SingletonEager = 1
-    """
-    New instance will be created on registering the callable object to container and the result will be
-    stored in the container.
-    """
-    SingletonLazy = 2
+    Singleton = 1
     """
     New instance will be created the first time container will be asked for object under given key. Both the callable
     and object will be stored in the container.
@@ -111,7 +106,7 @@ def register_object(self, key, obj):
     def register_callable(self, key, callable_object, lifetime=InstanceLifetime.NewInstancePerCall):
         """
         Registers a callable object that will be used to create a new instance of an object that will be returned upon
-        calling the get() method.
+        calling the get_instance() method.
 
         Based on the lifetime parameter, either the callable will be stored, and called whenever object is needed, or
         the callable will be called on registering, and the returned object will be stored.
@@ -123,9 +118,7 @@ def register_callable(self, key, callable_object, lifetime=InstanceLifetime.NewI
         """
         if lifetime == InstanceLifetime.NewInstancePerCall:
             provider = providers.NewInstancesProvider(callable_object)
-        elif lifetime == InstanceLifetime.SingletonEager:
-            provider = providers.EagerSingleInstanceProvider(callable_object)
-        elif lifetime == InstanceLifetime.SingletonLazy:
+        elif lifetime == InstanceLifetime.Singleton:
             provider = providers.LazySingleInstanceProvider(callable_object)
         else:
             raise TypeError('Unsupported instance lifetime.')
@@ -135,33 +128,31 @@ def register_callable(self, key, callable_object, lifetime=InstanceLifetime.NewI
     def register_callable_with_deps(self, key, callable_object, lifetime=InstanceLifetime.NewInstancePerCall):
         if lifetime == InstanceLifetime.NewInstancePerCall:
             provider = providers.NewInstancesWithDepsProvider(callable_object, self)
-        elif lifetime == InstanceLifetime.SingletonEager:
-            provider = providers.EagerSingleInstanceWithDepsProvider(callable_object, self)
-        elif lifetime == InstanceLifetime.SingletonLazy:
+        elif lifetime == InstanceLifetime.Singleton:
             provider = providers.LazySingleInstanceWithDepsProvider(callable_object, self)
         else:
             raise TypeError('Unsupported instance lifetime.')
 
         self._register_provider_for_key(key, provider)
 
-    def resolve(self, key):
+    def resolve(self, key, context=None):
         """
         Return instance based on what was registered for a given key.
 
         :param key: Key under which the object or callable was registered.
-        :return: Instance related to that key. 
+        :return: Instance related to that key.
         """
-        return self._resolve(key)
+        return self._resolve(key, context)
 
-    def build(self, cls):
+    def build(self, cls, context=None):
         """
         Build a new instance of class cls injecting dependencies of an object from objects registered in the container.
 
         :param cls: Class of which object to build.
         :return:
         """
         provider = providers.NewInstancesWithDepsProvider(cls, self)
-        return provider.get()
+        return provider.get_instance(context)
 
     @property
     def name(self):
@@ -180,9 +171,17 @@ def get_keys(self):
         """
         return self._locator.get_keys()
 
-    def _resolve(self, key):
-        instance_provider = self._locator.get(key)
-        return instance_provider.get()
+    def _resolve(self, key, context=None):
+        if context:
+            try:
+                item = context[key]
+            except KeyError:
+                pass
+            else:
+                return item
+
+        instance_provider = self._locator.locate(key)
+        return instance_provider.get_instance(context)
 
     def _register_provider_for_key(self, id, provider):
         self._locator.register(id, provider)
@@ -226,15 +225,25 @@ def get_all_keys(self):
 
         return result
 
-    def _resolve(self, id):
+    def _resolve(self, id, context=None):
         if isinstance(id, str):
             instance_id = self._name_resolver.parse(id)
+
             if instance_id.namespace:
                 container = self._sub_containers[instance_id.namespace]
-                return container.resolve(instance_id.id)
+                return container.resolve(instance_id.id, context)
             else:
-                provider = self._locator.get(instance_id.id)
-                return provider.get()
+                if context:
+                    try:
+                        item = context[instance_id.id]
+                    except KeyError:
+                        pass
+                    else:
+                        return item
+
+                provider = self._locator.locate(instance_id.id)
+                return provider.get_instance(context)
+
         else:
-            provider = self._locator.get(id)
-            return provider.get()
+            provider = self._locator.locate(id)
+            return provider.get_instance(context)

pyioc/locators.py

@@ -1,6 +1,6 @@
 # coding=utf-8
 """
-Module containing implementation of the service locator pattern.
+Module containing implementation of the service locator.
 """
 from __future__ import absolute_import
 
@@ -23,6 +23,28 @@ def generate_key(self, obj):
             return type(obj).__name__
 
 
+class UnregisteredKeyError(KeyError):
+    def __init__(self, key):
+        self._key = key
+
+    def __str__(self):
+        return 'There is no object registered for the given "%s" key' % self._key
+
+    def __unicode__(self):
+        return self.__str__()
+
+
+class KeyAlreadyRegisteredError(KeyError):
+    def __init__(self, key):
+        self._key = key
+
+    def __str__(self):
+        return 'There is already an object registered for the "%s" key' % self._key
+
+    def __unicode__(self):
+        return self.__str__()
+
+
 @six.add_metaclass(abc.ABCMeta)
 class LocatorBase(object):
     """
@@ -34,7 +56,7 @@ def register(self, key, obj):
         pass
 
     @abc.abstractmethod
-    def get(self, key):
+    def locate(self, key):
         pass
 
     @abc.abstractmethod
@@ -55,27 +77,27 @@ def __init__(self):
 
     def register(self, key, obj):
         """
-         Register object in locator for a specified key.
+         Register object in locator under a specified key.
 
          :param key: Key under which object will be registered.
          :param obj: Object to register.
          """
         if key in self._objects:
-            raise KeyError('There is already an object registered for the "%s" key' % key)
+            raise KeyAlreadyRegisteredError(key)
 
         self._set_instance(key, obj)
 
-    def get(self, key):
+    def locate(self, key):
         """
-        Gets the object for a given key.
+        Returns the object registered for a given key.
 
         :param key: Key under which object was registered.
         :return: Object registered under the given key.
         """
         try:
             instance = self._get_instance(key)
         except KeyError:
-            raise KeyError('There is no object registered for the given"%s" key' % key)
+            raise UnregisteredKeyError(key)
 
         return instance
 
@@ -101,7 +123,11 @@ def is_key_registered(self, key):
         :param key: Key to look for.
         :return: True if there is a key in the locator, otherwise False.
         """
-        return key in self._objects
+        try:
+            self._objects[key]
+        except KeyError:
+            return False
+        return True
 
     def get_keys(self):
         return list(self._objects.keys())

pyioc/providers.py

@@ -49,15 +49,15 @@ def validate_if_callable_without_args(obj):
 @six.add_metaclass(abc.ABCMeta)
 class ProviderBase(object):
     @abc.abstractmethod
-    def get(self):
+    def get_instance(self, context=None):
         pass
 
 
 class ObjectProvider(ProviderBase):
     def __init__(self, obj):
         self._obj = obj
 
-    def get(self):
+    def get_instance(self, context=None):
         return self._obj
 
 
@@ -66,7 +66,7 @@ def __init__(self, callable_object):
         validate_if_callable_without_args(callable_object)
         self._callable_object = callable_object
 
-    def get(self):
+    def get_instance(self, context=None):
         return self._callable_object()
 
 
@@ -76,7 +76,7 @@ def __init__(self, callable_object):
         self._instance = None
         self._callable_object = callable_object
 
-    def get(self):
+    def get_instance(self, context=None):
         if not self._instance:
             self._instance = self._callable_object()
         return self._instance
@@ -87,7 +87,7 @@ def __init__(self, callable_object):
         validate_if_callable_without_args(callable_object)
         self._instance = callable_object()
 
-    def get(self):
+    def get_instance(self, context=None):
         return self._instance
 
 
@@ -99,10 +99,10 @@ def __init__(self, callable_object, container):
         self._callable_object = callable_object
         self._container = container
 
-    def get(self):
-        return self._build_object()
+    def get_instance(self, context=None):
+        return self._build_object(context)
 
-    def _build_object(self):
+    def _build_object(self, context):
         if inspect.isclass(self._callable_object):
             if _check_if_init_implemented(self._callable_object):
                 args = inspect.getargspec(self._callable_object.__init__).args
@@ -116,29 +116,20 @@ def _build_object(self):
             if arg == 'self':
                 continue
 
-            new_args.append(self._container.resolve(arg))
+            new_args.append(self._container.resolve(arg, context))
 
         if new_args:
             return self._callable_object(*new_args)
 
         return self._callable_object()
 
 
-class EagerSingleInstanceWithDepsProvider(NewInstancesWithDepsProvider):
-    def __init__(self, callable_object, container):
-        super(EagerSingleInstanceWithDepsProvider, self).__init__(callable_object, container)
-        self._instance = self._build_object()
-
-    def get(self):
-        return self._instance
-
-
 class LazySingleInstanceWithDepsProvider(NewInstancesWithDepsProvider):
     def __init__(self, callable_object, container):
         super(LazySingleInstanceWithDepsProvider, self).__init__(callable_object, container)
         self._instance = None
 
-    def get(self):
+    def get_instance(self, context=None):
         if not self._instance:
-            self._instance = self._build_object()
+            self._instance = self._build_object(context)
         return self._instance

setup.py

@@ -3,7 +3,7 @@
 
 setup(
     name='pyioc',
-    version='0.2.1',
+    version='0.3.0',
     packages=['pyioc'],
     url='https://github.com/MrUPGrade/pyioc',
     license='MIT',

tests/conftest.py

@@ -36,7 +36,7 @@ def mock_container():
     :return: mocked locator with testclass1 and testclass2 registered
     """
 
-    def side_efect(name):
+    def side_efect(name, context=None):
         type_dict = {
             TEST_CLASS_1_NAME: TEST_CLASS_1_INSTANCE,
             TEST_CLASS_3_NAME: TEST_CLASS_3_INSTANCE

tests/functional_tests/test_containers.py

@@ -13,9 +13,8 @@ def get_container(cls):
     def test_registering_singleton(self):
         locator = ObjectLocator()
         container_class = self.get_container()
-        container = container_class()
-        container._locator = locator
-        container.register_callable(TEST_CLASS_1_NAME, TestClass1, lifetime=InstanceLifetime.SingletonLazy)
+        container = container_class(locator=locator)
+        container.register_callable(TEST_CLASS_1_NAME, TestClass1, lifetime=InstanceLifetime.Singleton)
 
         ret1 = locator.is_key_registered(TEST_CLASS_1_NAME)
         assert ret1 is True
@@ -24,13 +23,12 @@ def test_registering_singleton(self):
         ret3 = container.resolve(TEST_CLASS_1_NAME)
 
         assert isinstance(ret2, TestClass1)
-        assert id(ret2) == id(ret3)
+        assert ret2 is ret3
 
     def test_registering_class(self):
         locator = ObjectLocator()
         container_class = self.get_container()
-        container = container_class()
-        container._locator = locator
+        container = container_class(locator=locator)
         container.register_callable(TEST_CLASS_1_NAME, TestClass1)
 
         ret1 = locator.is_key_registered(TEST_CLASS_1_NAME)
@@ -40,13 +38,11 @@ def test_registering_class(self):
         ret3 = container.resolve(TEST_CLASS_1_NAME)
 
         assert isinstance(ret2, TestClass1)
-        assert id(ret2) != id(ret3)
+        assert ret2 is not ret3
 
     def test_registering_function_as_object(self):
-        locator = ObjectLocator()
         container_class = self.get_container()
         container = container_class()
-        container._locator = locator
         container.register_object(TEST_FUNC_1_NAME, TestFunc1)
 
         ret1 = container.resolve(TEST_FUNC_1_NAME)