smart_injection 0.0.0.alpha

data/lib/smart_core/injection/injector/injection_settings/incompatability_control.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Injection::Injector::InjectionSettings::IncompatabilityControl
+  class << self
+    # @param injectable [Class, Module]
+    # @param imports [Hash<String|Symbol,String>]
+    # @param memoize [Boolean]
+    # @param access [Symbol]
+    # @param bind [Symbol]
+    # @param from [NilClass, SmartCore::Container]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_incompatabilities!(injectable, imports, memoize, access, bind, from)
+      prevent_injectable_incompatabilities!(injectable)
+      prevent_imports_incompatabilites!(imports)
+      prevent_memoize_incompatabilites(memoize)
+      prevent_access_incompatabilites(access)
+      prevent_bind_incompatabilites(bind)
+      prevent_from_incompatabilites(from)
+    end
+
+    private
+
+    # @param injectable [Class, Module]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_injectable_incompatabilities!(injectable)
+      unless injectable.is_a?(Class) || injectable.is_a?(Module)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param imports [Hash<String|Symbol,String>]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_imports_incompatabilites!(imports)
+      unless imports.is_a?(::Hash)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+          Incorrect import list (should be a type of Hash)
+        ERROR_MESSAGE
+      end
+
+      unless imports.keys.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+          Some method aliases are incorret (they should be a type of String or Symbol)
+        ERROR_MESSAGE
+      end
+
+      unless imports.values.all? { |value| value.is_a?(String) }
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+          Some injection pathes are incorrect (they should be a type of String)
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param memoize [Boolean]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_memoize_incompatabilites(memoize)
+      unless memoize.is_a?(::TrueClass) || memoize.is_a?(::FalseClass)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param access [Symbol]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_access_incompatabilites(access)
+      unless SmartCore::Injection::Injector::InjectionSettings::ACCESS_MARKS.include?(access)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param bind [Symbol]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_bind_incompatabilites(bind)
+      unless SmartCore::Injection::Injector::InjectionSettings::BINDING_STRATEGIES.include?(bind)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param from [NilClass, SmartCore::Container]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_from_incompatabilites(from)
+      unless from.is_a?(NilClass) || from.is_a?(SmartCore::Container)
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+        ERROR_MESSAGE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Injection::Injector::Modulizer
+  class << self
+    # @param containers [Array<SmartCore::Container>]
+    # @return [Module]
+    #
+    # @api private
+    # @since 0.1.0
+    def with_containers(containers)
+      prevent_inconsistency!(containers)
+      build_container_injectable_module(containers)
+    end
+
+    # @param base_klass [Class, Module]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inject_to(base_klass)
+      base_klass.include(::SmartCore::Injection::DSL)
+    end
+
+    private
+
+    # @param containers [Array<SmartCore::Container>]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_inconsistency!(containers)
+      unless containers.is_a?(Array) && containers.all? { |cont| cont.is_a?(SmartCore::Container) }
+        raise(SmartCore::Injection::ArgumentError, <<~ERROR_MESSAGE)
+          Injectable containers should be a type of SmartCore::Container
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param containers [Array<SmartCore::Container>]
+    # @return [Module]
+    #
+    # @api private
+    # @since 0.1.0
+    def build_container_injectable_module(containers)
+      Module.new do
+        define_singleton_method :included do |base_klass|
+          base_klass.include(::SmartCore::Injection::DSL)
+          base_klass.register_container(*containers)
+        end
+      end
+    end
+  end
+end

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(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,73 @@
+# 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
+  end
+
+  # @param dependency_path [String]
+  # @return [Any]
+  #
+  # @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
+
+    raise(resolving_error)
+  end
+
+  # @param import_path [String]
+  # @param observer [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def observe(import_path, &observer)
+    # TODO: implement
+  end
+
+  private
+
+  # @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 block [Block]
+  # @yield [container]
+  # @yieldparam container [SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def each_container(&block)
+    yield(explicitly_passed_container) if explicitly_passed_container
+    registered_containers.reverse_each(&block)
+  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
+      @bind = 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(@value)
+      end
+    end
+  end
+
+  private
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def with_barrier(&block)
+    @barrier.synchronize(&block)
+  end
+end