[imports] dependency rebinding

Author: 0exp

Gemfile.lock

@@ -2,7 +2,7 @@ PATH
   remote: .
   specs:
     smart_injection (0.0.0.alpha2)
-      smart_container (~> 0.7)
+      smart_container (~> 0.8, >= 0.8.1)
       smart_engine (~> 0.7)
 
 GEM
@@ -79,7 +79,7 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)
-    smart_container (0.7.0)
+    smart_container (0.8.1)
       smart_engine (~> 0.5)
     smart_engine (0.7.0)
     thread_safe (0.3.6)

README.md

@@ -84,14 +84,14 @@ class MiniService
   register_container(AppContainer, ServiceContainer)
 
   # import dependencies to an instance
-  import { db: 'data_storage.main' }, bind: :dynamic, access: :private
-  import { rnd: 'rands.alphanum' }, bind: :static, memoize: true
+  import({ db: 'data_storage.main' }, bind: :dynamic, access: :private)
+  import({ rnd: 'rands.alphanum' }, bind: :static, memoize: true)
 
   # import dependencies to a class
-  import_static { cache: 'data_storage.cache', hexer: 'rands.hex' }, bind: :static
+  import_static({ cache: 'data_storage.cache', hexer: 'rands.hex' }, bind: :static)
 
   # import from a non-registered container
-  import { phone_client: 'phone_clients.nexmo' }, from: GlobalContainer
+  import({ phone_client: 'phone_clients.nexmo' }, from: GlobalContainer)
 
   def call
     db # => returns data_storage.main

lib/smart_core/injection/injector/container_set.rb

@@ -3,6 +3,8 @@
 # @api private
 # @since 0.1.0
 class SmartCore::Injection::Injector::ContainerSet
+  require_relative 'container_set/adding_listener'
+
   # @since 0.1.0
   include Enumerable
 
@@ -12,6 +14,7 @@ class SmartCore::Injection::Injector::ContainerSet
   # @since 0.1.0
   def initialize
     @containers = [] # NOTE: we use Array cuz we need an ordered set
+    @adding_listeners = []
     @access_lock = SmartCore::Engine::Lock.new
   end
 
@@ -25,6 +28,17 @@ def add(container)
   end
   alias_method :<<, :add
 
+  # @param listener [Block]
+  # @yield [container]
+  # @yieldparam container [SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def listen_addings(&listener)
+    thread_safe { add_adding_listener(listener) }
+  end
+
   # @param block [Block]
   # @yield [container]
   # @yieldparam container [SmartCore::Container]
@@ -63,6 +77,18 @@ def list
   # @since 0.1.0
   attr_reader :containers
 
+  # @return [Array<SmartCore::Injection::Injector::ContainerSet::AddingListener>]
+  attr_reader :adding_listeners
+
+  # @param listener [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_adding_listener(listener)
+    adding_listeners << SmartCore::Injection::Injector::ContainerSet::AddingListener.new(listener)
+  end
+
   # @param container [SmartCore::Container]
   # @return [void]
   #
@@ -73,6 +99,7 @@ def append_container(container)
     #   - #concant is used to prevent container duplications in ordered set;
     #   - @containers should have an ordered unified container list;
     containers.concat([container])
+    adding_listeners.each { |listener| listener.notify(container) }
   end
 
   # @param block [Block]

lib/smart_core/injection/injector/container_set/adding_listener.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Injection::Injector::ContainerSet::AddingListener
+  # @param listener [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(listener)
+    @listener = listener
+  end
+
+  # @param cotnainer [SmartCore::Container]
+  #
+  # @api private
+  # @since 0.1.0
+  def notify(container)
+    listener.call(container)
+  end
+
+  private
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :listener
+end

lib/smart_core/injection/locator.rb

@@ -39,7 +39,7 @@ def resolve_dependency
   # @api private
   # @since 0.1.0
   def rebind_dependency
-    dependency.rebind { container_proxy.resolve(import_path) }
+    dependency.rebind { container_proxy.resolve_dependency(import_path) }
   end
   alias_method :rebind!, :rebind_dependency
 

lib/smart_core/injection/locator/container_proxy.rb

@@ -12,6 +12,8 @@ class SmartCore::Injection::Locator::ContainerProxy
   def initialize(registered_containers, explicitly_passed_container)
     @registered_containers = registered_containers
     @explicitly_passed_container = explicitly_passed_container
+    @observers = Hash.new { |h, k| h[k] = [] }
+    registered_containers.listen_addings { |container| listen_changes(container) }
   end
 
   # @param dependency_path [String]
@@ -49,11 +51,21 @@ def resolve_dependency(dependency_path)
   # @api private
   # @since 0.1.0
   def observe(import_path, &observer)
-    # TODO: implement
+    register_observer(import_path, observer)
+
+    each_container do |container|
+      container.observe(import_path) { |path, cntr| process_changement(cntr, path) }
+    end
   end
 
   private
 
+  # @return [Hash<String,Proc>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :observers
+
   # @return [SmartCore::Injection::Injector::ContainerSet]
   #
   # @api private
@@ -66,15 +78,65 @@ def observe(import_path, &observer)
   # @since 0.1.0
   attr_reader :explicitly_passed_container
 
+  # @param import_path [NilClass, String]
+  # @param container [SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def process_changement(container, import_path = nil)
+    observed_pathes = import_path ? [import_path] : observed_import_pathes
+
+    observed_pathes.each do |observed_path|
+      suitable_container = each_container.find { |cntr| cntr.key?(observed_path) }
+      break unless suitable_container
+      notify_observers(observed_path) if suitable_container == container
+    end
+  end
+
+  # @param import_path [String]
+  # @param observer [SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def register_observer(import_path, observer)
+    observers[import_path] << observer
+  end
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  def observed_import_pathes
+    observers.keys
+  end
+
+  # @param import_pathes [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def notify_observers(*import_pathes)
+    import_pathes.each { |import_path| observers.fetch(import_path).each(&:call) }
+  end
+
   # @param block [Block]
   # @yield [container]
   # @yieldparam container [SmartCore::Container]
-  # @return [void]
+  # @return [Enumerable]
   #
   # @api private
   # @since 0.1.0
   def each_container(&block)
-    yield(explicitly_passed_container) if explicitly_passed_container
-    registered_containers.reverse_each(&block)
+    enumerator = Enumerator.new do |yielder|
+      if explicitly_passed_container
+        yielder.yield(explicitly_passed_container)
+      else
+        registered_containers.reverse_each(&yielder)
+      end
+    end
+
+    block_given? ? enumerator.each(&block) : enumerator.each
   end
 end

lib/smart_core/injection/locator/dependency.rb

@@ -20,7 +20,7 @@ def initialize
   # @since 0.1.0
   def rebind(&block)
     with_barrier do
-      @bind = false
+      @binded = false
       bind(&block)
     end
   end
@@ -36,7 +36,7 @@ def bind(&block)
         @value
       else
         @binded = true
-        @value = yield(@value)
+        @value = yield
       end
     end
   end

lib/smart_core/injection/locator/factory.rb

@@ -11,7 +11,7 @@ class << self
     # @since 0.1.0
     def create(injection_settings, import_key, import_path)
       container_proxy = create_container_proxy(injection_settings)
-      locator = create_locator(import_path, container_proxy).tap do
+      create_locator(import_path, container_proxy).tap do |locator|
         control_injection_memoization(injection_settings, container_proxy, locator, import_path)
       end
     end
@@ -47,7 +47,9 @@ def create_locator(import_path, container_proxy)
     # @api private
     # @since 0.1.0
     def control_injection_memoization(injection_settings, container_proxy, locator, import_path)
-      container_proxy.observe(import_path) { locator.rebind! } unless injection_settings.memoize
+      container_proxy.observe(import_path) do
+        locator.rebind!
+      end unless injection_settings.memoize
     end
   end
 end

smart_injection.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'smart_engine',    '~> 0.7'
-  spec.add_runtime_dependency 'smart_container', '~> 0.7'
+  spec.add_runtime_dependency 'smart_container', '~> 0.8', '>= 0.8.1'
 
   spec.add_development_dependency 'bundler',          '~> 2.1'
   spec.add_development_dependency 'rake',             '~> 13.0'

spec/smart_injection_spec.rb

@@ -5,6 +5,71 @@
     expect(SmartCore::Injection::VERSION).not_to be nil
   end
 
+  specify 'dependency changement and rebinding (considering the memoization and not)' do
+    SimpleContainer = SmartCore::Container.define do
+      namespace(:database) do
+        register(:logger) { 'simple_logger' }
+      end
+
+      register(:game) { 'overwatch' }
+    end
+
+    AnotherSimpleContainer = SmartCore::Container.define do
+      namespace(:database) do
+        register(:logger) { 'another_simple_logger' }
+      end
+    end
+
+    class SimpleService
+      include SmartCore::Injection
+
+      register_container(SimpleContainer)
+
+      import({ db_logger: 'database.logger' })
+      import({ another_db_logger: 'database.logger' }, from: AnotherSimpleContainer)
+      import({ game: 'game' }, memoize: true)
+
+      def call
+        { db_logger: db_logger, another_db_logger: another_db_logger, game: game }
+      end
+    end
+
+    service = SimpleService.new
+
+    expect(service.call).to eq({
+      db_logger: 'simple_logger',
+      another_db_logger: 'another_simple_logger',
+      game: 'overwatch'
+    })
+
+    # re-registration of non-memoized import
+    SimpleContainer.fetch(:database).register(:logger) { 'changed_simple_logger' }
+
+    expect(service.call).to eq({
+      db_logger: 'changed_simple_logger', # changed
+      another_db_logger: 'another_simple_logger',
+      game: 'overwatch'
+    })
+
+    # re-registration of non-memoized import
+    AnotherSimpleContainer.fetch(:database).register(:logger) { 'changed_another_logger' }
+
+    expect(service.call).to eq({
+      db_logger: 'changed_simple_logger',
+      another_db_logger: 'changed_another_logger', # changed
+      game: 'overwatch'
+    })
+
+    # re-registration of memoized import
+    SimpleContainer.register(:game) { 'warcraft' }
+
+    expect(service.call).to eq({
+      db_logger: 'changed_simple_logger',
+      another_db_logger: 'changed_another_logger',
+      game: 'overwatch' # not changed (memoized value)
+    })
+  end
+
   specify do
     AppContainer = SmartCore::Container.define do
       namespace(:database) do
@@ -73,7 +138,8 @@ def call
 
     # inheritance from inherited entity
     class Hydra < Chimera
-      import({ db_logger: 'database.logger', kickbox: 'clients.kickbox', head: 'heads.snake' }, bind: :static, access: :private)
+      import({ db_logger: 'database.logger', kickbox: 'clients.kickbox', head: 'heads.snake' },
+             bind: :static, access: :private)
     end
 
     hydra = Hydra.new