smart_container 0.1.0

data/lib/smart_core/container/entities.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Container::Entities
+  require_relative 'entities/base'
+  require_relative 'entities/dependency'
+  require_relative 'entities/dependency_builder'
+  require_relative 'entities/namespace'
+  require_relative 'entities/namespace_builder'
+end

data/lib/smart_core/container/entities/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::Entities::Base
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :external_name
+
+  # @param external_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(external_name)
+    @external_name = external_name
+  end
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def reveal; end
+end

data/lib/smart_core/container/entities/dependency.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::Entities::Dependency < SmartCore::Container::Entities::Base
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  alias_method :dependency_name, :external_name
+
+  # @param dependency_name [String]
+  # @param dependency_definition [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(dependency_name, dependency_definition)
+    super(dependency_name)
+    @dependency_definition = dependency_definition
+  end
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def reveal
+    dependency_definition.call
+  end
+
+  private
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :dependency_definition
+end

data/lib/smart_core/container/entities/dependency_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::Entities::DependencyBuilder
+  class << self
+    # @param dependency_name [String]
+    # @param dependency_definition [Proc]
+    # @return [SmartCore::Container::Entities::Dependency]
+    #
+    # @api private
+    # @since 0.1.0
+    def build(dependency_name, dependency_definition)
+      new(dependency_name, dependency_definition).build
+    end
+  end
+
+  # @param dependency_name [String]
+  # @param dependency_definition [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(dependency_name, dependency_definition)
+    @dependency_name = dependency_name
+    @dependency_definition = dependency_definition
+  end
+
+  # @return [SmartCore::Container::Entities::Dependency]
+  #
+  # @api private
+  # @since 0.1.0
+  def build
+    SmartCore::Container::Entities::Dependency.new(dependency_name, dependency_definition)
+  end
+
+  private
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :dependency_name
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :dependency_definition
+end

data/lib/smart_core/container/entities/namespace.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::Entities::Namespace < SmartCore::Container::Entities::Base
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  alias_method :namespace_name, :external_name
+
+  # @param namespace_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(namespace_name)
+    super(namespace_name)
+    @container_klass = Class.new(SmartCore::Container)
+    @container_instance = nil
+    @lock = SmartCore::Container::ArbitaryLock.new
+  end
+
+  # @return [SmartCore::Container]
+  #
+  # @api private
+  # @since 0.1.0
+  def reveal
+    thread_safe { container_instance }
+  end
+
+  # @param dependencies_definition [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def append_definitions(dependencies_definition)
+    thread_safe { container_klass.instance_eval(&dependencies_definition) }
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def freeze!
+    thread_safe { container_instance.freeze! }
+  end
+
+  private
+
+  # @return [Class<SmartCore::Container>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :container_klass
+
+  # @return [SmartCore::Container]
+  #
+  # @api private
+  # @since 0.1.0
+  def container_instance
+    @container_instance ||= container_klass.new
+  end
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def thread_safe(&block)
+    @lock.thread_safe(&block)
+  end
+end

data/lib/smart_core/container/entities/namespace_builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Container::Entities::NamespaceBuilder
+  class << self
+    # @param namespace_name [String]
+    # @return [SmartCore::Container::Entities::Namespace]
+    #
+    # @api private
+    # @since 0.1.0
+    def build(namespace_name)
+      new(namespace_name).build
+    end
+  end
+
+  # @param namespace_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(namespace_name)
+    @namespace_name = namespace_name
+  end
+
+  # @return [SmartCore::Container::Entities::Namespace]
+  #
+  # @api private
+  # @since 0.1.0
+  def build
+    SmartCore::Container::Entities::Namespace.new(namespace_name)
+  end
+
+  private
+
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :namespace_name
+end

data/lib/smart_core/container/errors.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class SmartCore::Container
+  # @api public
+  # @since 0.1.0
+  Error = Class.new(SmartCore::Error)
+
+  # @api public
+  # @since 0.1.0
+  ArgumentError = Class.new(SmartCore::ArgumentError)
+
+  # @api public
+  # @since 0.1.0
+  IncompatibleEntityNameError = Class.new(ArgumentError)
+
+  # @see SmartCore::Container::Registry
+  #
+  # @api public
+  # @since 0.1.0
+  FrozenRegistryError = Class.new(SmartCore::FrozenError)
+
+  # @api public
+  # @since 0.1.0
+  FetchError = Class.new(Error)
+
+  # @see SmartCore::Container::DependencyCompatability::General
+  # @see SmartCore::Container::DependencyCompatability::Definition
+  # @see SmartCore::Container::DependencyCompatability::Registry
+  #
+  # @api public
+  # @since 0.1.0
+  DependencyOverNamespaceOverlapError = Class.new(Error)
+
+  # @see SmartCore::Container::DependencyCompatability::General
+  # @see SmartCore::Container::DependencyCompatability::Definition
+  # @see SmartCore::Container::DependencyCompatability::Registry
+  #
+  # @api public
+  # @since 0.1.0
+  NamespaceOverDependencyOverlapError = Class.new(Error)
+
+  # @see SmartCore::Container::DependencyResolver
+  # @see SmartCore::Container::Registry
+  #
+  # @api public
+  # @since 0.1.0
+  class ResolvingError < FetchError
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :path_part
+
+    # @param message [String]
+    # @param path_part [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def initialize(messegae = nil, path_part:)
+      @path_part = path_part
+      super(message)
+    end
+  end
+end

data/lib/smart_core/container/key_guard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# @api priavate
+# @since 0.1.0
+module SmartCore::Container::KeyGuard
+  class << self
+    # @param key [Symbol, String]
+    # @return [void]
+    #
+    # @raise [SmartCore::Container::IncompatibleEntityNameError]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_incomparabilities!(key)
+      raise(
+        SmartCore::Container::IncompatibleEntityNameError,
+        'Namespace/Dependency name should be a symbol or a string'
+      ) unless key.is_a?(String) || key.is_a?(Symbol)
+    end
+
+    # @param key [Symbol, String]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def indifferently_accessable_key(key)
+      prevent_incomparabilities!(key)
+      key.to_s
+    end
+  end
+end

data/lib/smart_core/container/mixin.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+module SmartCore::Container::Mixin
+  class << self
+    # @param base_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def included(base_klass)
+      # rubocop:disable Layout/LineLength
+      base_klass.instance_variable_set(:@__smart_core_container_access_lock__, SmartCore::Container::ArbitaryLock.new)
+      base_klass.instance_variable_set(:@__smart_core_container_klass__, Class.new(SmartCore::Container))
+      base_klass.instance_variable_set(:@__smart_core_container__, nil)
+      # rubocop:enable Layout/LineLength
+
+      base_klass.extend(ClassMethods)
+      base_klass.include(InstanceMethods)
+      base_klass.singleton_class.prepend(ClassInheritance)
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassInheritance
+    # @param child_klass [CLass]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inherited(child_klass)
+      inherited_container_klass = Class.new(@__smart_core_container_klass__)
+
+      # rubocop:disable Layout/LineLength
+      child_klass.instance_variable_set(:@__smart_core_container_access_lock__, SmartCore::Container::ArbitaryLock.new)
+      child_klass.instance_variable_set(:@__smart_core_container_klass__, inherited_container_klass)
+      child_klass.instance_variable_set(:@__smart_core_container__, nil)
+      # rubocop:enable Layout/LineLength
+      super
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassMethods
+    # @param freeze_state [Boolean]
+    # @param block [Proc]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.1.0
+    def dependencies(freeze_state: false, &block)
+      @__smart_core_container_access_lock__.thread_safe do
+        @__smart_core_container_klass__.instance_eval(&block) if block_given?
+        @__smart_core_container_klass__.instance_eval { freeze_state! } if freeze_state
+      end
+    end
+
+    # @return [SmartCore::Container]
+    #
+    # @api public
+    # @since 0.1.0
+    def container
+      @__smart_core_container_access_lock__.thread_safe do
+        @__smart_core_container__ ||= @__smart_core_container_klass__.new
+      end
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module InstanceMethods
+    # @return [SmartCore::Container]
+    #
+    # @api public
+    # @since 0.1.0
+    def container
+      self.class.container
+    end
+  end
+end

data/lib/smart_core/container/registry.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# rubocop:disable Metrics/ClassLength
+class SmartCore::Container::Registry
+  # @since 0.1.0
+  include Enumerable
+
+  # @return [Hash<Symbol,SmartCore::Container::Entity>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :registry
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize
+    @registry = {}
+    @access_lock = SmartCore::Container::ArbitaryLock.new
+  end
+
+  # @param entity_path [String, Symbol]
+  # @return [SmartCore::Container::Entity]
+  #
+  # @api private
+  # @since 0.1.0
+  def resolve(entity_path)
+    thread_safe { fetch_entity(entity_path) }
+  end
+
+  # @param name [String, Symbol]
+  # @param dependency_definition [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def register_dependency(name, &dependency_definition)
+    thread_safe { add_dependency(name, dependency_definition) }
+  end
+
+  # @param name [String, Symbol]
+  # @param dependencies_definition [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def register_namespace(name, &dependencies_definition)
+    thread_safe { add_namespace(name, dependencies_definition) }
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def freeze!
+    thread_safe { freeze_state! }
+  end
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def frozen?
+    thread_safe { state_frozen? }
+  end
+
+  # @param block [Block]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  def each(&block)
+    thread_safe { enumerate(&block) }
+  end
+
+  # @return [Hash<String|Symbol,SmartCore::Container::Entities::Base|Any>]
+  #
+  # @api private
+  # @since 0.1.0
+  def hash_tree(resolve_dependencies: false)
+    thread_safe { build_hash_tree(resolve_dependencies: resolve_dependencies) }
+  end
+  alias_method :to_h, :hash_tree
+  alias_method :to_hash, :hash_tree
+
+  private
+
+  # @return [Mutex]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :lock
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  def state_frozen?
+    registry.frozen?
+  end
+
+  # @return [Hash<String|Symbol,SmartCore::Container::Entities::Base|Any>]
+  #
+  # @api private
+  # @since 0.1.0
+  def build_hash_tree(resolve_dependencies: false)
+    {}.tap do |tree|
+      enumerate do |(entity_name, entity)|
+        case entity
+        when SmartCore::Container::Entities::Namespace
+          tree[entity_name] = entity.reveal.hash_tree(resolve_dependencies: resolve_dependencies)
+        when SmartCore::Container::Entities::Dependency
+          tree[entity_name] = resolve_dependencies ? entity.reveal : entity
+        end
+      end
+    end
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def freeze_state!
+    registry.freeze.tap do
+      enumerate do |(entity_name, entity)|
+        entity.freeze! if entity.is_a?(SmartCore::Container::Entities::Namespace)
+      end
+    end
+  end
+
+  # @param block
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  def enumerate(&block)
+    block_given? ? registry.each(&block) : registry.each
+  end
+
+  # @paramm entity_path [String, Symbol]
+  # @return [SmartCore::Container::Entity]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.1.0
+  def fetch_entity(entity_path)
+    dependency_name = indifferently_accessable_name(entity_path)
+    registry.fetch(dependency_name)
+  rescue KeyError
+    raise(SmartCore::Container::ResolvingError.new(<<~MESSAGE, path_part: dependency_name))
+      Entity with \"#{dependency_name}\" name does not exist
+    MESSAGE
+  end
+
+  # @param dependency_name [String, Symbol]
+  # @param dependency_definition [Proc]
+  # @return [SmartCore::Container::Entities::Dependency]
+  #
+  # @raise [SmartCore::Container::DependencyOverNamespaceOverlapError]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_dependency(dependency_name, dependency_definition)
+    if state_frozen?
+      raise(SmartCore::Container::FrozenRegistryError, 'Can not modify frozen registry!')
+    end
+    dependency_name = indifferently_accessable_name(dependency_name)
+    prevent_namespace_overlap!(dependency_name)
+
+    dependency_entity = SmartCore::Container::Entities::DependencyBuilder.build(
+      dependency_name, dependency_definition
+    )
+
+    dependency_entity.tap { registry[dependency_name] = dependency_entity }
+  end
+
+  # @param namespace_name [String, Symbol]
+  # @param dependencies_definition [Proc]
+  # @return [SmartCore::Container::Entities::Namespace]
+  #
+  # @raise [SmartCore::Container::NamespaceOverDependencyOverlapError]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_namespace(namespace_name, dependencies_definition)
+    if state_frozen?
+      raise(SmartCore::Container::FrozenRegistryError, 'Can not modify frozen registry!')
+    end
+    namespace_name = indifferently_accessable_name(namespace_name)
+    prevent_dependency_overlap!(namespace_name)
+
+    # rubocop:disable Layout/RescueEnsureAlignment
+    namespace_entity = begin
+      fetch_entity(namespace_name)
+    rescue SmartCore::Container::FetchError
+      registry[namespace_name] = SmartCore::Container::Entities::NamespaceBuilder.build(
+        namespace_name
+      )
+    end
+    # rubocop:enable Layout/RescueEnsureAlignment
+
+    namespace_entity.tap { namespace_entity.append_definitions(dependencies_definition) }
+  end
+
+  # @param name [String, Symbol]
+  # @return [void]
+  #
+  # @see [SmartCore::Container::KeyGuard]
+  #
+  # @api private
+  # @since 0.1.0
+  def indifferently_accessable_name(name)
+    SmartCore::Container::KeyGuard.indifferently_accessable_key(name)
+  end
+
+  # @param dependency_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_namespace_overlap!(dependency_name)
+    SmartCore::Container::DependencyCompatability::Registry.prevent_namespace_overlap!(
+      self, dependency_name
+    )
+  end
+
+  # @param namespace_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_dependency_overlap!(namespace_name)
+    SmartCore::Container::DependencyCompatability::Registry.prevent_dependency_overlap!(
+      self, namespace_name
+    )
+  end
+
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def thread_safe(&block)
+    @access_lock.thread_safe(&block)
+  end
+end
+# rubocop:enable Metrics/ClassLength