smart_container 0.1.0

data/lib/smart_core/container/definition_dsl/commands/instantiation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DefinitionDSL::Commands::Instantiation
+  require_relative 'instantiation/compose'
+  require_relative 'instantiation/freeze_state'
+end

data/lib/smart_core/container/definition_dsl/commands/instantiation/compose.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SmartCore::Container::DefinitionDSL::Commands::Instantiation
+  # @api private
+  # @since 0.1.0
+  class Compose < SmartCore::Container::DefinitionDSL::Commands::Base
+    # @since 0.1.0
+    self.inheritable = true
+
+    # @param container_klass [Class<SmartCore::Container>]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def initialize(container_klass)
+      raise(
+        SmartCore::ArgumentError,
+        'Container class should be a subtype of Quantum::Container'
+      ) unless container_klass < SmartCore::Container
+
+      @container_klass = container_klass
+    end
+
+    # @param registry [SmartCore::Container::Registry]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(registry)
+      SmartCore::Container::RegistryBuilder.build_state(
+        container_klass, registry, ignored_commands: [
+          SmartCore::Container::DefinitionDSL::Commands::Instantiation::FreezeState
+        ]
+      )
+    end
+
+    # @return [SmartCore::Container::DefinitionDSL::Commands::Instantiation::Compose]
+    #
+    # @api private
+    # @since 0.1.0
+    def dup
+      self.class.new(container_klass)
+    end
+
+    private
+
+    # @return [Class<SmartCore::Container>]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :container_klass
+  end
+end

data/lib/smart_core/container/definition_dsl/commands/instantiation/freeze_state.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SmartCore::Container::DefinitionDSL::Commands::Instantiation
+  # @api private
+  # @since 0.1.0
+  class FreezeState < SmartCore::Container::DefinitionDSL::Commands::Base
+    # @since 0.1.0
+    self.inheritable = false
+
+    # @param registry [SmartCore::Container::Registry]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(registry)
+      registry.freeze!
+    end
+
+    # @return [SmartCore::Container::DefinitionDSL::Commands::Instantiation::FreezeState]
+    #
+    # @api private
+    # @since 0.1.0
+    def dup
+      self.class.new
+    end
+  end
+end

data/lib/smart_core/container/definition_dsl/inheritance.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DefinitionDSL::Inheritance
+  class << self
+    # @option base [Class<SmartCore::Container>]
+    # @option child [Class<SmartCore::Container>]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inherit(base:, child:)
+      child.__container_definition_commands__.concat(
+        base.__container_definition_commands__, &:inheritable?
+      )
+
+      child.__container_instantiation_commands__.concat(
+        base.__container_instantiation_commands__, &:inheritable?
+      )
+    end
+  end
+end

data/lib/smart_core/container/dependency_compatability.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DependencyCompatability
+  require_relative 'dependency_compatability/general'
+  require_relative 'dependency_compatability/definition'
+  require_relative 'dependency_compatability/registry'
+end

data/lib/smart_core/container/dependency_compatability/definition.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DependencyCompatability::Definition
+  class << self
+    # @since 0.1.0
+    include SmartCore::Container::DependencyCompatability::General
+
+    # @param container_klass [Class<SmartCore::Container>]
+    # @param dependency_name [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def potential_namespace_overlap?(container_klass, dependency_name)
+      anonymous_container = Class.new(container_klass).new
+      anonymous_container.register(dependency_name, &(proc {}))
+      false
+    rescue SmartCore::Container::DependencyOverNamespaceOverlapError
+      true
+    end
+
+    # @param container_klass [Class<SmartCore::Container>]
+    # @param namespace_name [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def potential_dependency_overlap?(container_klass, namespace_name)
+      anonymous_container = Class.new(container_klass).new
+      anonymous_container.namespace(namespace_name, &(proc {}))
+      false
+    rescue SmartCore::Container::NamespaceOverDependencyOverlapError
+      true
+    end
+  end
+end

data/lib/smart_core/container/dependency_compatability/general.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DependencyCompatability::General
+  # @param context [Class<SmartCore::Container>, SmartCore::Container::Registry]
+  # @param dependency_name [String, Symbol]
+  # @return [void]
+  #
+  # @raise [SmartCore::Container::DependencyOverNamespaceOverlapError]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_namespace_overlap!(context, dependency_name)
+    raise(
+      SmartCore::Container::DependencyOverNamespaceOverlapError,
+      "Trying to overlap already registered '#{dependency_name}' namespace " \
+      "with '#{dependency_name}' dependency!"
+    ) if potential_namespace_overlap?(context, dependency_name)
+  end
+
+  # @param context [Class<SmartCore::Container>, SmartCore::Container::Registry]
+  # @param namespace_name [String, Symbol]
+  # @return [void]
+  #
+  # @raise [SmartCore::Container::NamespaceOverDependencyOverlapError]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_dependency_overlap!(context, namespace_name)
+    raise(
+      SmartCore::Container::NamespaceOverDependencyOverlapError,
+      "Trying to overlap already registered '#{namespace_name}' dependency " \
+      "with '#{namespace_name}' namespace!"
+    ) if potential_dependency_overlap?(context, namespace_name)
+  end
+
+  # @param context [Class<SmartCore::Container>, SmartCore::Container::Registry]
+  # @param dependency_name [String, Symbol]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def potential_namespace_overlap?(context, dependency_name)
+    # :nocov:
+    raise NoMethodError
+    # :nocov:
+  end
+
+  # @param context [Class<SmartCore::Container>, SmartCore::Container::Registry]
+  # @param namespace_name [String, Symbol]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def potential_dependency_overlap?(context, namespace_name)
+    # :nocov:
+    raise NoMethodError
+    # :nocov:
+  end
+end

data/lib/smart_core/container/dependency_compatability/registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DependencyCompatability::Registry
+  class << self
+    # @since 0.1.0
+    include SmartCore::Container::DependencyCompatability::General
+
+    # @param registry [SmartCore::Container::Registry]
+    # @param dependency_name [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def potential_namespace_overlap?(registry, dependency_name)
+      registry.any? do |(entity_name, entity)|
+        next unless entity.is_a?(SmartCore::Container::Entities::Namespace)
+        entity.namespace_name == dependency_name
+      end
+    end
+
+    # @param registry [SmartCore::Container::Registry]
+    # @param namespace_name [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def potential_dependency_overlap?(registry, namespace_name)
+      registry.any? do |(entity_name, entity)|
+        next unless entity.is_a?(SmartCore::Container::Entities::Dependency)
+        entity.dependency_name == namespace_name
+      end
+    end
+  end
+end

data/lib/smart_core/container/dependency_resolver.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::DependencyResolver
+  require_relative 'dependency_resolver/route'
+
+  class << self
+    # @param container [SmartCore::Container]
+    # @param dependency_path [String, Symbol]
+    # @return [SmartCore::Container, Any]
+    #
+    # @see SmartCore::Container::Registry#resolve
+    # @see SmartCore::Container::Entities::Namespace#reveal
+    # @see SmartCore::Container::Entities::Dependency#reveal
+    #
+    # @api private
+    # @since 0.1.0
+    def fetch(container, dependency_path)
+      container.registry.resolve(dependency_path).reveal
+    end
+
+    # @param container [SmartCore::Container]
+    # @param dependency_path [String, Symbol]
+    # @return [SmartCore::Container, Any]
+    #
+    # @see SmartCore::Container::Registry#resolve
+    # @see SmartCore::Container::Entities::Namespace#reveal
+    # @see SmartCore::Container::Entities::Dependency#reveal
+    #
+    # @raise [SmartCore::Container::ResolvingError]
+    #
+    # @api private
+    # @since 0.1.0
+    # @version 0.1.0
+    def resolve(container, dependency_path)
+      entity = container
+      Route.build(dependency_path).each do |cursor|
+        entity = entity.registry.resolve(cursor.current_path)
+        prevent_cursor_overflow!(cursor, entity)
+        entity = entity.reveal
+      end
+      entity
+    rescue SmartCore::Container::ResolvingError => error
+      process_resolving_error(dependency_path, error)
+    end
+
+    private
+
+    # @param cursor [SmartCore::Container::DependencyResolver::Route::Cursor]
+    # @param entity [SmartCore::Container::Entities::Base]
+    # @return [void]
+    #
+    # @raise [SmartCore::Container::ResolvingError]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_cursor_overflow!(cursor, entity)
+      if cursor.last? && entity.is_a?(SmartCore::Container::Entities::Namespace)
+        raise(
+          SmartCore::Container::ResolvingError.new(
+            'Trying to resolve a namespace as a dependency',
+            path_part: cursor.current_path
+          )
+        )
+      end
+
+      if !cursor.last? && entity.is_a?(SmartCore::Container::Entities::Dependency)
+        raise(
+          SmartCore::Container::ResolvingError.new(
+            'Trying to resolve nonexistent dependency',
+            path_part: cursor.current_path
+          )
+        )
+      end
+    end
+
+    # @param dependency_path [String, Symbol]
+    # @param error [SmartCore::Container::ResolvingError]
+    # @return [void]
+    #
+    # @raise [SmartCore::Container::ResolvingError]
+    #
+    # @api private
+    # @since 0.1.0
+    def process_resolving_error(dependency_path, error)
+      full_dependency_path = Route.build_path(dependency_path, error.path_part)
+      raise(SmartCore::Container::ResolvingError.new(<<~MESSAGE, path_part: full_dependency_path))
+        #{error.message} (incorrect path: "#{full_dependency_path}")
+      MESSAGE
+    end
+  end
+end

data/lib/smart_core/container/dependency_resolver/route.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::DependencyResolver::Route
+  require_relative 'route/cursor'
+
+  # @since 0.1.0
+  include Enumerable
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  PATH_PART_SEPARATOR = '.'
+
+  class << self
+    # @param path [String, Symbol]
+    # @return [SmartCore::Container::DependencyResolver::Route]
+    #
+    # @api private
+    # @since 0.1.0
+    def build(path)
+      new(SmartCore::Container::KeyGuard.indifferently_accessable_key(path))
+    end
+
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def build_path(*path_parts)
+      path_parts.join(PATH_PART_SEPARATOR)
+    end
+  end
+
+  # @return [Integer]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :size
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :path
+
+  # @param path [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(path)
+    @path = path
+    @path_parts = path.split(PATH_PART_SEPARATOR).freeze
+    @size = @path_parts.size
+  end
+
+  # @param block [Block]
+  # @yield cursor [SmartCore::Container::DependencyResolver::Route::Cursor]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  def each(&block)
+    enumerator = Enumerator.new do |yielder|
+      path_parts.each_with_index do |path_part, path_part_index|
+        cursor = Cursor.new(path_part, path_part_index, self)
+        yielder.yield(cursor)
+      end
+    end
+
+    block_given? ? enumerator.each(&block) : enumerator
+  end
+
+  private
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :path_parts
+end

data/lib/smart_core/container/dependency_resolver/route/cursor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::DependencyResolver::Route::Cursor
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :path_part
+  alias_method :current_path, :path_part
+
+  # @param path_part [String]
+  # @param path_part_index [Integer]
+  # @param route [SmartCore::Container::DependencyResolver::Route]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(path_part, path_part_index, route)
+    @path_part = path_part
+    @path_part_index = path_part_index
+    @route = route
+  end
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def last?
+    route.size <= (path_part_index + 1)
+  end
+
+  private
+
+  # @return [Integer]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :path_part_index
+
+  # @return [SmartCore::Container::DependencyResolver::Route]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :route
+end