smart_core 0.4.0 → 0.5.0

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SmartCore::Container::DependencyCompatability
+  # @api private
+  # @since 0.5.0
+  class CommandSet < Abstract
+    class << self
+      # @param command_set [SmartCore::Container::CommandSet]
+      # @param dependency_name [String]
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.5.0
+      def potential_namespace_overlap?(command_set, dependency_name)
+        command_set.any? do |command|
+          next unless command.is_a?(SmartCore::Container::Commands::Namespace)
+          command.namespace_name == dependency_name
+        end
+      end
+
+      # @param command_set [SmartCore::Container::CommandSet]
+      # @param namespace_name [String]
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.5.0
+      def potential_dependency_overlap?(command_set, namespace_name)
+        command_set.any? do |command|
+          next unless command.is_a?(SmartCore::Container::Commands::Register)
+          command.dependency_name == namespace_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SmartCore::Container::DependencyCompatability
+  # @api private
+  # @since 0.5.0
+  class Registry < Abstract
+    class << self
+      # @param registry [SmartCore::Container::Regsitry]
+      # @param dependency_name [String]
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.5.0
+      def potential_namespace_overlap?(registry, dependency_name)
+        registry.any? do |registered_dependency|
+          next unless registered_dependency.is_a?(SmartCore::Container::Namespace)
+          # NOTE: registered_dependency is a namespace
+          registered_dependency.external_name == dependency_name
+        end
+      end
+
+      # @param registry [SmartCore::Container::Regsitry]
+      # @param namespace_name [String]
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.5.0
+      def potential_dependency_overlap?(registry, namespace_name)
+        registry.any? do |registered_dependency|
+          next unless registered_dependency.is_a?(SmartCore::Container::Dependency)
+          # NOTE: registered_dependency is a dependency/memoized dependency
+          registered_dependency.external_name == namespace_name
+        end
+      end
+    end
+  end
+end

data/lib/smart_core/container/dependency_compatability.rb

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

data/lib/smart_core/container/dependency_resolver.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+module SmartCore::Container::DependencyResolver
+  class << self
+    # @param registry [SmartCore::Container::Registry]
+    # @return [Any]
+    #
+    # @api private
+    # @since 0.5.0
+    def resolve(registry, dependency_path)
+      registry.resolve(dependency_path).call
+    end
+  end
+end

data/lib/smart_core/container/entity.rb

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

data/lib/smart_core/container/exceptions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class SmartCore::Container
+  # @api public
+  # @since 0.5.0
+  Error = Class.new(SmartCore::Error)
+
+  # @api public
+  # @since 0.5.0
+  ArgumentError = Class.new(SmartCore::ArgumentError)
+
+  # @api public
+  # @since 0.5.0
+  NamespaceOverlapError = Class.new(Error)
+
+  # @api public
+  # @since 0.5.0
+  DependencyOverlapError = Class.new(Error)
+
+  # @api public
+  # @since 0.5.0
+  UnexistentDependencyError = Class.new(Error)
+
+  # @api public
+  # @since 0.5.0
+  FrozenRegistryError = Class.new(SmartCore::FrozenError)
+
+  # @api private
+  # @since 0.5.0
+  IncompatibleDependencyTree = Class.new(Error)
+end

data/lib/smart_core/container/key_guard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# @api priavate
+# @since 0.5.0
+module SmartCore::Container::KeyGuard
+  class << self
+    # @param key [Symbol, String]
+    # @return [void]
+    #
+    # @raise [SmartCore::Container::ArgumentError]
+    #
+    # @api private
+    # @since 0.5.0
+    def prevent_incomparabilities!(key)
+      raise(
+        SmartCore::Container::ArgumentError,
+        '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.5.0
+    def indifferently_accessable_key(key)
+      prevent_incomparabilities!(key)
+      key.to_s
+    end
+  end
+end

data/lib/smart_core/container/memoized_dependency.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Container::MemoizedDependency < SmartCore::Container::Dependency
+  # @param external_name [String]
+  # @param dependency_definition [Proc]
+  # @param options [Hash<Symbol,Any>]
+  # @return [void]
+  #
+  # @todo option list
+  # @see [SmartCore::Container::Dependency]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(external_name, dependency_definition, **options)
+    @memoized_call = nil
+    super
+  end
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def call
+    thread_safe { @memoized_call ||= dependency_definition.call }
+  end
+end

data/lib/smart_core/container/mixin.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.5.0
+module SmartCore::Container::Mixin
+  class << self
+    # @param base_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def included(base_klass)
+      # rubocop:disable Metrics/LineLength
+      base_klass.instance_variable_set(:@__smart_core_container_access_lock__, Mutex.new)
+      base_klass.instance_variable_set(:@__smart_core_container_definition_lock__, Mutex.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 Metrics/LineLength
+
+      base_klass.extend(ClassMethods)
+      base_klass.include(InstanceMethods)
+      base_klass.singleton_class.prepend(ClassInheritance)
+    end
+  end
+
+  # @api private
+  # @since 0.5.0
+  module ClassInheritance
+    # @param child_klass [CLass]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def inherited(child_klass)
+      inherited_container_klass = Class.new(@__smart_core_container_klass__)
+
+      child_klass.instance_variable_set(:@__smart_core_container_access_lock__, Mutex.new)
+      child_klass.instance_variable_set(:@__smart_core_container_definition_lock__, Mutex.new)
+      child_klass.instance_variable_set(:@__smart_core_container_klass__, inherited_container_klass)
+      child_klass.instance_variable_set(:@__smart_core_container__, nil)
+
+      super
+    end
+  end
+
+  # @api private
+  # @since 0.5.0
+  module ClassMethods
+    # @param block [Proc]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.5.0
+    def dependencies(&block)
+      @__smart_core_container_definition_lock__.synchronize do
+        @__smart_core_container_klass__.instance_eval(&block) if block_given?
+      end
+    end
+
+    # @return [SmartCore::Container]
+    #
+    # @api public
+    # @since 0.5.0
+    def container
+      @__smart_core_container_definition_lock__.synchronize do
+        @__smart_core_container__ ||= @__smart_core_container_klass__.new
+      end
+    end
+  end
+
+  # @api private
+  # @since 0.5.0
+  module InstanceMethods
+    # @return [SmartCore::Container]
+    #
+    # @api public
+    # @since 0.5.0
+    def container
+      self.class.container
+    end
+  end
+end

data/lib/smart_core/container/namespace.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Container::Namespace < SmartCore::Container::Entity
+  # @param external_name [String]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(external_name)
+    @container = Class.new(SmartCore::Container)
+    @container_instance = nil
+    @access_lock = Mutex.new
+    super(external_name)
+  end
+
+  # @param dependency_definitions [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def append_definitions(dependency_definitions)
+    container.instance_eval(&dependency_definitions)
+  end
+
+  # @return [SmartCore::Container]
+  #
+  # @api private
+  # @since 0.5.0
+  def call
+    thread_safe { @container_instance ||= container.new }
+  end
+
+  private
+
+  # @return [Class<SmartCore::Container>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :container
+
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def thread_safe(&block)
+    @access_lock.synchronize(&block)
+  end
+end

data/lib/smart_core/container/registry.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+class SmartCore::Container
+  # @api private
+  # @since 0.5.0
+  class Registry
+    # @since 0.5.0
+    include Enumerable
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def initialize
+      @access_lock = Mutex.new
+      @registry = {}
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def freeze
+      thread_safe { freeze_state }
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def frozen?
+      thread_safe { state_frozen? }
+    end
+
+    # @param dependency_path [String, Symbol]
+    # @return [SmartCore::Container::Namespace, SmartCore::Container::Dependnecy]
+    #
+    # @api private
+    # @since 0.5.0
+    def resolve(dependency_path)
+      thread_safe { fetch_dependency(dependency_path) }
+    end
+
+    # @param name [String, Symbol]
+    # @param options [Hash<Symbol,Any>]
+    # @param dependency_definition [Block]
+    # @return [void]
+    #
+    # @todo option list
+    #
+    # @api private
+    # @since 0.5.0
+    def register(name, **options, &dependency_definition)
+      thread_safe do
+        raise(
+          SmartCore::Container::FrozenRegistryError,
+          'Can not modify frozen registry'
+        ) if state_frozen?
+
+        append_dependency(name, dependency_definition, **options)
+      end
+    end
+
+    # @param name [String, Symbol]
+    # @param dependency_definitions [Block]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def namespace(name, &dependency_definitions)
+      thread_safe do
+        raise(
+          SmartCore::Container::FrozenRegistryError,
+          'Can not modify frozen registry'
+        ) if state_frozen?
+
+        append_namespace(name, dependency_definitions)
+      end
+    end
+
+    # @param block [Block]
+    # @return [Enumerable]
+    #
+    # @api private
+    # @since 0.5.0
+    def each(&block)
+      thread_safe { block_given? ? registry.each_value(&block) : registry.each_value }
+    end
+
+    # @return [Hash<Symbol,Any>]
+    #
+    # @api private
+    # @since 0.5.0
+    def to_h
+      # TODO: implement :)
+    end
+
+    private
+
+    # @return [Mutex]
+    #
+    # @api private
+    # @since 0.5.0
+    attr_reader :access_lock
+
+    # @return [Hash<Symbol,SmartCore::Container::Entity>]
+    #
+    # @api private
+    # @since 0.5.0
+    attr_reader :registry
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.5.0
+    def state_frozen?
+      registry.frozen?
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def freeze_state
+      registry.freeze
+    end
+
+    # @paramm dependency_path [String, Symbol]
+    # @return [SmartCore::Container::Namespace, SmartCore::Container::Dependency]
+    #
+    # @api private
+    # @since 0.5.0
+    def fetch_dependency(dependency_path)
+      # TODO: rabbit style dependnecy path
+      name = indifferently_accessable_name(dependency_path)
+      registry.fetch(name)
+    rescue KeyError
+      raise(
+        SmartCore::Container::UnexistentDependencyError,
+        "Dependencny with '#{name}' name does not exist!"
+      )
+    end
+
+    # @param dependency_name [String, Symbol]
+    # @param dependency_definition [Proc]
+    # @param options [Hash<Symbol,Any>]
+    # @return [void]
+    #
+    # @todo option list
+    # @raise [SmartCore::Container::NamespaceOverlapError]
+    #
+    # @api private
+    # @since 0.5.0
+    def append_dependency(dependency_name, dependency_definition, **options)
+      dependency_name = indifferently_accessable_name(dependency_name)
+      prevent_namespace_overlap!(dependency_name)
+      dependency = DependencyBuilder.build(dependency_name, dependency_definition, **options)
+
+      registry[dependency_name] = dependency
+    end
+
+    # @param namespace_name [String, Symbol]
+    # @param dependency_definitions [Proc]
+    # @return [void]
+    #
+    # @raise [SmartCore::Container::DependencyOverlapError]
+    #
+    # @api private
+    # @since 0.5.0
+    def append_namespace(namespace_name, dependency_definitions)
+      namespace_name = indifferently_accessable_name(namespace_name)
+      prevent_dependency_overlap!(namespace_name)
+
+      # rubocop:disable Layout/RescueEnsureAlignment
+      namespace = begin
+        registry.fetch(namespace_name)
+      rescue KeyError
+        registry[namespace_name] = SmartCore::Container::Namespace.new(namespace_name)
+      end
+      # rubocop:enable Layout/RescueEnsureAlignment
+
+      namespace.append_definitions(dependency_definitions)
+    end
+
+    # @param name [String, Symbol]
+    # @return [void]
+    #
+    # @see [SmartCore::Container::KeyGuard]
+    #
+    # @api private
+    # @since 0.5.0
+    def indifferently_accessable_name(name)
+      SmartCore::Container::KeyGuard.indifferently_accessable_key(name)
+    end
+
+    # @param dependency_name [String]
+    # @retrun [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def prevent_namespace_overlap!(dependency_name)
+      DependencyCompatability::Registry.prevent_namespace_overlap!(
+        self, dependency_name
+      )
+    end
+
+    # @param namespace_name [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.5.0
+    def prevent_dependency_overlap!(namespace_name)
+      DependencyCompatability::Registry.prevent_dependency_overlap!(
+        self, namespace_name
+      )
+    end
+
+    # @param block [Proc]
+    # @return [Any]
+    #
+    # @api private
+    # @since 0.5.0
+    def thread_safe(&block)
+      @access_lock.synchronize(&block)
+    end
+  end
+end

data/lib/smart_core/container/registry_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+module SmartCore::Container::RegistryBuilder
+  class << self
+    # @param commands [SmartCore::Container::CommandSet]
+    # @return [SmartCore::Container::Registry]
+    #
+    # @api private
+    # @since 0.5.0
+    def build(commands)
+      SmartCore::Container::Registry.new.tap do |registry|
+        commands.each { |command| command.call(registry) }
+      end
+    end
+  end
+end