smart_injection 0.0.0 → 0.1.0

data/lib/smart_core/injection/injector/strategies.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Injection::Injector::Strategies
+  require_relative 'strategies/method_injection'
+end

data/lib/smart_core/injection/injector/strategies/method_injection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Injection::Injector::Strategies::MethodInjection
+  class << self
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inject_instance_method(injection_settings)
+      inject_dependency(injection_settings, injection_settings.instance_level_injectable)
+    end
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inject_class_method(injection_settings)
+      inject_dependency(injection_settings, injection_settings.class_level_injectable)
+    end
+
+    private
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @param injectable [Class, Module]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inject_dependency(injection_settings, injectable)
+      injection_settings.each_import do |import_key, import_path|
+        locator = build_locator(injection_settings, import_key, import_path)
+        process_injection_bindings(injection_settings, locator)
+        injection = build_injection(injection_settings, import_key, locator)
+        inject_injection(injection_settings, injection, injectable)
+      end
+    end
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @param import_key [String, Symbol]
+    # @param import_path [String]
+    # @return [SmartCore::Injection::Locator]
+    #
+    # @api private
+    # @since 0.1.0
+    def build_locator(injection_settings, import_key, import_path)
+      SmartCore::Injection::Locator::Factory.create(injection_settings, import_key, import_path)
+    end
+
+    # @param locator [SmartCore::Injection::Locator]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def process_injection_bindings(injection_settings, locator)
+      locator.bind! if injection_settings.bind_static?
+    end
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @param import_key [String, Symbol]
+    # @param locator [SmartCore::Injection::Locator]
+    # @return [Module]
+    #
+    # @api private
+    # @since 0.1.0
+    def build_injection(injection_settings, import_key, locator)
+      Module.new do
+        define_method(import_key) { locator.resolve_dependency }
+
+        case injection_settings.access
+        when :public then public(import_key)
+        when :private then private(import_key)
+        when :protected then protected(import_key)
+        end
+      end
+    end
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @param injection [Module]
+    # @param injectable [Class, Module]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inject_injection(injection_settings, injection, injectable)
+      injectable.include(injection)
+    end
+  end
+end

data/lib/smart_core/injection/locator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Injection::Locator
+  require_relative 'locator/container_proxy'
+  require_relative 'locator/dependency'
+  require_relative 'locator/factory'
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :import_path
+
+  # @param import_path [String]
+  # @param container_proxy [SmartCore::Injection::Locator::ContainerProxy]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(import_path, container_proxy)
+    @import_path = import_path
+    @container_proxy = container_proxy
+    @dependency = SmartCore::Injection::Locator::Dependency.new
+  end
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def resolve_dependency
+    dependency.bind { container_proxy.resolve_dependency(import_path) }
+  end
+  alias_method :bind!, :resolve_dependency
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def rebind_dependency
+    dependency.rebind { container_proxy.resolve_dependency(import_path) }
+  end
+  alias_method :rebind!, :rebind_dependency
+
+  private
+
+  # @return [SmartCore::Injection::Locator::Dependency]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :dependency
+
+  # @return [SmartCore::Injection::Locator::ContainerProxy]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :container_proxy
+end

data/lib/smart_core/injection/locator/container_proxy.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Injection::Locator::ContainerProxy
+  # @param registered_containers [SmartCore::Injection::Injector::ContainerSet]
+  # @param explicitly_passed_container [NilClass, SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  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]
+  # @return [Any]
+  #
+  # @raise [SmartCore::Injection::NoRegisteredContainersError]
+  # @raise [SmartCore::Container::ResolvingError]
+  #
+  # @api private
+  # @since 0.1.0
+  def resolve_dependency(dependency_path)
+    resolving_error = nil
+
+    each_container do |container|
+      begin # rubocop:disable Style/RedundantBegin
+        return container.resolve(dependency_path)
+      rescue SmartCore::Container::ResolvingError => error
+        resolving_error = error
+      end
+    end
+
+    unless resolving_error
+      raise(SmartCore::Injection::NoRegisteredContainersError, <<~ERROR_MESSAGE)
+        You haven't registered any containers for import.
+      ERROR_MESSAGE
+    else
+      raise(resolving_error)
+    end
+  end
+
+  # @param import_path [String]
+  # @param observer [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def observe(import_path, &observer)
+    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
+  # @since 0.1.0
+  attr_reader :registered_containers
+
+  # @return [NilClass, SmartCore::Container]
+  #
+  # @api private
+  # @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 [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  def each_container(&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

data/lib/smart_core/injection/locator/dependency.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Injection::Locator::Dependency
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize
+    @binded = false
+    @value = nil
+    @barrier = SmartCore::Engine::Lock.new
+  end
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def rebind(&block)
+    with_barrier do
+      @binded = false
+      bind(&block)
+    end
+  end
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api public
+  # @since 0.7.0
+  def bind(&block)
+    with_barrier do
+      if @binded
+        @value
+      else
+        @binded = true
+        @value = yield
+      end
+    end
+  end
+
+  private
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def with_barrier(&block)
+    @barrier.synchronize(&block)
+  end
+end

data/lib/smart_core/injection/locator/factory.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Injection::Locator::Factory
+  class << self
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @return [SmartCore::Injection::Locator]
+    #
+    # @api private
+    # @since 0.1.0
+    def create(injection_settings, import_key, import_path)
+      container_proxy = create_container_proxy(injection_settings)
+      create_locator(import_path, container_proxy).tap do |locator|
+        control_injection_memoization(injection_settings, container_proxy, locator, import_path)
+      end
+    end
+
+    private
+
+    # @return [SmartCore::Injection::Locator::ContainerProxy]
+    #
+    # @api private
+    # @since 0.1.0
+    def create_container_proxy(injection_settings)
+      SmartCore::Injection::Locator::ContainerProxy.new(
+        injection_settings.container_set,
+        injection_settings.from
+      )
+    end
+
+    # @param import_path [String]
+    # @param container_proxy [SmartCore::Injection::Locator::ContainerProxy]
+    # @return [SmartCore::Injection::Locator]
+    #
+    # @api private
+    # @since 0.1.0
+    def create_locator(import_path, container_proxy)
+      SmartCore::Injection::Locator.new(import_path, container_proxy)
+    end
+
+    # @param injection_settings [SmartCore::Injection::Injector::InjectionSettings]
+    # @param locator [SmartCore::Injection::Locator]
+    # @param import_path [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def control_injection_memoization(injection_settings, container_proxy, locator, import_path)
+      container_proxy.observe(import_path) do
+        locator.rebind!
+      end unless injection_settings.memoize
+    end
+  end
+end

data/lib/smart_core/injection/version.rb

@@ -6,6 +6,6 @@ module SmartCore
     #
     # @api public
     # @since 0.1.0
-    VERSION = '0.0.0'
+    VERSION = '0.1.0'
   end
 end

data/smart_injection.gemspec

@@ -5,10 +5,10 @@ require_relative 'lib/smart_core/injection/version'
 Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new('>= 2.4.10')
 
-  spec.name    = "smart_injection"
+  spec.name    = 'smart_injection'
   spec.version = SmartCore::Injection::VERSION
-  spec.authors = ["Rustam Ibragimov"]
-  spec.email   = ["iamdaiver@gmail.com"]
+  spec.authors = ['Rustam Ibragimov']
+  spec.email   = ['iamdaiver@gmail.com']
 
   spec.summary     = 'DI principles and idioms realized in scope of Ruby'
   spec.description = 'DI principles and idioms realized in scope of Ruby'
@@ -30,9 +30,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'smart_engine',    '~> 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.add_development_dependency 'rspec',            '~> 3.9'
   spec.add_development_dependency 'armitage-rubocop', '~> 0.85'
   spec.add_development_dependency 'simplecov',        '~> 0.18'
+  spec.add_development_dependency 'pry',              '~> 0.13'
 end