smart_core 0.4.0 → 0.5.0

data/lib/smart_core/container.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.5.0
+class SmartCore::Container
+  require_relative 'container/exceptions'
+  require_relative 'container/commands'
+  require_relative 'container/command_set'
+  require_relative 'container/key_guard'
+  require_relative 'container/entity'
+  require_relative 'container/dependency'
+  require_relative 'container/memoized_dependency'
+  require_relative 'container/namespace'
+  require_relative 'container/dependency_builder'
+  require_relative 'container/registry'
+  require_relative 'container/registry_builder'
+  require_relative 'container/dependency_compatability'
+  require_relative 'container/dependency_resolver'
+  require_relative 'container/definition_dsl'
+  require_relative 'container/mixin'
+
+  # TODO: container composition
+  # TODO: #merge / #merge!
+
+  # @since 0.5.0
+  include DefinitionDSL
+
+  # @return [void]
+  #
+  # @api public
+  # @since 0.5.0
+  def initialize
+    build_registry
+    @access_lock = Mutex.new
+  end
+
+  # @param dependency_name [String, Symbol]
+  # @param options [Hash<Symbol,Any>]
+  # @param dependency_definition [Block]
+  # @return [void]
+  #
+  # @todo option list
+  #
+  # @api public
+  # @since 0.5.0
+  def register(dependency_name, **options, &dependency_definition)
+    thread_safe do
+      registry.register(dependency_name, **options, &dependency_definition)
+    end
+  end
+
+  # @return [void]
+  #
+  # @api public
+  # @since 0.5.0
+  def freeze
+    thread_safe { registry.freeze }
+  end
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.5.0
+  def frozen?
+    thread_safe { registry.frozen? }
+  end
+
+  # @param namespace_name [String, Symbol]
+  # @param dependency_definitions [Block]
+  # @return [void]
+  #
+  # @api public
+  # @since 0.5.0
+  def namespace(namespace_name, &dependency_definitions)
+    thread_safe do
+      registry.namespace(namespace_name, &dependency_definitions)
+    end
+  end
+
+  # @param dependency_path [String, Symbol]
+  # @return [Any]
+  #
+  # @api public
+  # @since 0.5.0
+  def resolve(dependency_path)
+    thread_safe do
+      DependencyResolver.resolve(registry, dependency_path)
+    end
+  end
+
+  # @return [void]
+  #
+  # @api public
+  # @since 0.5.0
+  def reload!
+    thread_safe { build_registry }
+  end
+
+  private
+
+  # @return [SmartCore::Container::Registry]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :registry
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def build_registry
+    @registry = RegistryBuilder.build(self.class.__commands__)
+  end
+
+  # @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/exceptions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SmartCore
+  # @api public
+  # @since 0.5.0
+  Error = Class.new(StandardError)
+
+  # @api public
+  # @since 0.5.0
+  ArgumentError = Class.new(::ArgumentError)
+
+  # @api public
+  # @since 0.5.0
+  FrozenError = begin # rubocop:disable Naming/ConstantName
+    # :nocov:
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+      Class.new(::FrozenError)
+    else
+      Class.new(::RuntimeError)
+    end
+    # :nocov:
+  end
+end

data/lib/smart_core/initializer/attribute/builder.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::Attribute
+  module Builder
+    class << self
+      # @return [Proc]
+      #
+      # @api private
+      # @since 0.5.0
+      DEFAULT_FINALIZE = -> (value) { value }.freeze
+
+      # @param name [String, Symbol]
+      # @option type [Symbol]
+      # @option privacy [Symbol, String]
+      # @param options [Hash<Symbol,Any>]
+      #   - :default (see SmartCore::Initializer::Attribute#initialize)
+      #   - :finalize (see SmartCore::Initializer::Attribute#initialize)
+      # @return [SmartCore::Initializer::Attribute]
+      #
+      # @raise [SmartCore::Initializer::IncorrectAttributeNameError]
+      # @raise [SmartCore::Initializer::UnregisteredTypeError]
+      # @raise [SmartCore::Initializer::AttributeError]
+      #
+      # @api private
+      # @since 0.5.0
+      def build(name, type: :__any__, privacy: :default, finalize: DEFAULT_FINALIZE, **options)
+        name      = represent_name_attr(name)
+        type      = represent_type_attr(type)
+        privacy   = represent_privacy_attr(privacy)
+        finalizer = represent_finalizer_attr(finalize)
+
+        SmartCore::Initializer::Attribute.new(name, type, privacy, finalizer, **options)
+      end
+
+      private
+
+      # @param finalize [Proc, String, Symbol]
+      # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Lambda]
+      # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Method]
+      #
+      # @api private
+      # @since 0.5.0
+      def represent_finalizer_attr(finalize)
+        raise(
+          SmartCore::Initializer::IncompatibleFinalizerTypeError,
+          ':finalize should be a symbol/string or a proc/lambda'
+        ) unless finalize.is_a?(Proc) || finalize.is_a?(Symbol) || finalize.is_a?(String)
+
+        ValueFinalizer.build(finalize)
+      end
+
+      # @param privacy [Symbol, String]
+      # @return [Symbol]
+      #
+      # @api private
+      # @since 0.5.0
+      def represent_privacy_attr(privacy)
+        begin
+          PRIVACY_MODES.fetch(privacy.to_sym)
+        rescue KeyError
+          raise(
+            SmartCore::Initializer::UnsupportedAttributePrivacyError,
+            "Required :#{privacy} privacy mode is not supported!"
+          )
+        end
+      end
+
+      # @param name [Symbol, String]
+      # @return [Symbol, String]
+      #
+      # @api private
+      # @since 0.5.0
+      def represent_name_attr(name)
+        name.tap do |value|
+          raise(
+            SmartCore::Initializer::IncorrectAttributeNameError,
+            'Attribute name should be a symbol or a string'
+          ) unless value.is_a?(Symbol) || value.is_a?(String)
+        end
+      end
+
+      # @param type [String]
+      # @return [Symbol]
+      #
+      # @api private
+      # @since 0.5.0
+      def represent_type_attr(type)
+        type.tap do |value|
+          raise(
+            SmartCore::Initializer::UnregisteredTypeError,
+            "type :#{value} is not registered!"
+          ) unless SmartCore::Initializer.types.has_type?(value)
+        end
+      end
+    end
+  end
+end

data/lib/smart_core/initializer/attribute/value_finalizer/lambda.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::Attribute::ValueFinalizer::Lambda
+  # @param finalizer [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(finalizer)
+    @finalizer = finalizer
+  end
+
+  # @param value [Any]
+  # @param instance [Any]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def finalize(value, instance)
+    finalizer.call(value)
+  end
+
+  private
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :finalizer
+end

data/lib/smart_core/initializer/attribute/value_finalizer/method.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::Attribute::ValueFinalizer::Method
+  # @param finalizer [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(finalizer)
+    @finalizer = finalizer
+  end
+
+  # @param value [Any]
+  # @param instance [Any]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def finalize(value, instance)
+    instance.send(finalizer, value)
+  end
+
+  private
+
+  # @return [String, Symbol]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :finalizer
+end

data/lib/smart_core/initializer/attribute/value_finalizer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SmartCore::Initializer::Attribute::ValueFinalizer
+  require_relative 'value_finalizer/lambda'
+  require_relative 'value_finalizer/method'
+
+  class << self
+    # @param finalize [Proc, String, Symbol]
+    # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Lambda]
+    # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Method]
+    #
+    # @api private
+    # @since 0.5.0
+    def build(finalize)
+      case finalize
+      when Symbol, String
+        Method.new(finalize)
+      when Proc
+        Lambda.new(finalize)
+      end
+      # NOTE: other variants are impossible (by SmartCore::Initializer::Attribute::Builder)
+    end
+  end
+end

data/lib/smart_core/initializer/attribute.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::Attribute
+  require_relative 'attribute/builder'
+  require_relative 'attribute/value_finalizer'
+
+  # @return [Hash<Symbol,Symbol>]
+  #
+  # @api private
+  # @since 0.5.0
+  PRIVACY_MODES = {
+    private:   :private,
+    protected: :protected,
+    public:    :public,
+    default:   :public
+  }.freeze
+
+  # @return [Symbol]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :name
+
+  # @return [String, Symbol]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :type
+
+  # @return [Symbol]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :privacy
+
+  # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Lambda]
+  # @return [SmartCore::Initializer::Attribute::ValueFinalizer::Method]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :finalizer
+
+  # @return [Hash<Symbol,Any>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :options
+
+  # @param name [String, Symbol]
+  # @param type [Symbol] (see SmartCore::Initializer::TypeSet, SmartCore::Initializer::Type)
+  # @param privacy [Symbol
+  # @param finalizer [SmartCore::Initializer::Attribute::ValueFinalizer::Lambda/Method]
+  # @param options [HAsh<Symbol,Any>] Supported options:
+  #   - :default [Proc] see #default_value
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(name, type, privacy, finalizer, **options)
+    @name = name
+    @type = type
+    @privacy = privacy
+    @finalizer = finalizer
+    @options = options
+  end
+
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.5.0
+  def has_default_value?
+    options.key?(:default)
+  end
+
+  # @param value [Any]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def validate_value_type!(value)
+    type_checker = SmartCore::Initializer.get_type(type)
+
+    raise(
+      SmartCore::Initializer::ArgumentError,
+      "Incorrect type of <#{name}> attribute " \
+      "(given: #{value.class}, expected: :#{type_checker.name})"
+    ) unless type_checker.comparable?(value)
+  end
+
+  # @return [Any]
+  #
+  # @raise [SmartCore::Initializer::ArgumentError]
+  #
+  # @api private
+  # @since 0.5.0
+  def default_value
+    default_value = options.fetch(:default) do
+      raise(SmartCore::Initializer::ArgumentError, 'Default value is not provided.')
+    end
+
+    default_value.is_a?(Proc) ? default_value.call : default_value
+  end
+
+  # @param value [Any]
+  # @param instance [Any]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def finalize(value, instance)
+    finalizer.finalize(value, instance)
+  end
+
+  # @return [SmartCore::Intializer::Attribute]
+  #
+  # @api private
+  # @since 0.5.0
+  def dup
+    self.class.new(name, type, privacy, finalizer, **options)
+  end
+end

data/lib/smart_core/initializer/attribute_definer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::AttributeDefiner
+  # @param processed_klass [Class]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(processed_klass)
+    @processed_klass = processed_klass
+    @definition_lock = Mutex.new
+  end
+
+  # @param param_name [Symbol, String]
+  # @param param_type [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def define_param(param_name, param_type = :__any__, **options)
+    thread_safe do
+      parameter = build_attribute(param_name, param_type, **options)
+      prevent_intersection_with_already_defined_option(parameter)
+      append_parameter(parameter)
+    end
+  end
+
+  # @param param_names [Array<String, Symbol>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def define_params(*param_names)
+    thread_safe do
+      parameters = param_names.map do |param_name|
+        build_attribute(param_name).tap do |parameter|
+          prevent_intersection_with_already_defined_option(parameter)
+        end
+      end
+
+      parameters.each { |parameter| append_parameter(parameter) }
+    end
+  end
+
+  # @param option_name [Symbol, String]
+  # @param option_type [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def define_option(option_name, option_type = :__any__, **options)
+    thread_safe do
+      option = build_attribute(option_name, option_type, **options)
+      prevent_intersection_with_already_defined_param(option)
+
+      append_option(option)
+    end
+  end
+
+  # @param option_names [Array<String, Symbol>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def define_options(*option_names)
+    thread_safe do
+      options = option_names.map do |option_name|
+        build_attribute(option_name).tap do |option|
+          prevent_intersection_with_already_defined_param(option)
+        end
+      end
+
+      options.each { |option| append_option(option) }
+    end
+  end
+
+  private
+
+  # @return [Class]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :processed_klass
+
+  # @param attribute_name [Symbol, String]
+  # @param attribute_type [String, Symbol]
+  # @param attribute_options [Hash<Symbol,Any>]
+  # @return [SmartCore::Initializer::Attribute]
+  #
+  # @api private
+  # @since 0.5.0
+  def build_attribute(attribute_name, attribute_type = :__any__, **attribute_options)
+    SmartCore::Initializer::Attribute::Builder.build(
+      attribute_name, type: attribute_type, **attribute_options
+    )
+  end
+
+  # @param parameter [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def append_parameter(parameter)
+    processed_klass.__params__ << parameter
+    processed_klass.send(:attr_reader, parameter.name)
+    processed_klass.send(parameter.privacy, parameter.name)
+  end
+
+  # @param option [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def append_option(option)
+    processed_klass.__options__ << option
+    processed_klass.send(:attr_reader, option.name)
+    processed_klass.send(option.privacy, option.name)
+  end
+
+  # @param parameter [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @raise [SmartCore::Initializer::OptionOverlapError]
+  #
+  # @api private
+  # @since 0.5.0
+  def prevent_intersection_with_already_defined_option(parameter)
+    if processed_klass.__options__.conflicts_with?(parameter)
+      raise(
+        SmartCore::Initializer::OptionOverlapError,
+        "You have already defined option with name :#{parameter.name}"
+      )
+    end
+  end
+
+  # @param option [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @raise [SmartCore::Initializer::ParamOverlapError]
+  #
+  # @api private
+  # @since 0.5.0
+  def prevent_intersection_with_already_defined_param(option)
+    if processed_klass.__params__.conflicts_with?(option)
+      raise(
+        SmartCore::Initializer::ParamOverlapError,
+        "You have already defined param with name :#{option.name}"
+      )
+    end
+  end
+
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def thread_safe(&block)
+    @definition_lock.synchronize(&block)
+  end
+end