smart_initializer 0.0.0

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Initializer::Attribute::Definer
+  # @param klass [Class]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(klass)
+    @klass = klass
+    @lock = SmartCore::Engine::Lock.new
+  end
+
+  # @param name [String, Symbol]
+  # @param type [String, Symbol, SmartCore::Types::Primitive]
+  # @param privacy [String, Symbol]
+  # @param finalize [String, Symbol, Proc]
+  # @param cast [Boolean]
+  # @param dynamic_options [Hash<Symbol,Any>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def define_parameter(name, type, privacy, finalize, cast, dynamic_options)
+    thread_safe do
+      attribute = build_attribute(name, type, privacy, finalize, cast, dynamic_options)
+      prevent_option_overlap(attribute)
+      add_parameter(attribute)
+    end
+  end
+
+  # @param names [Array<String, Symbol>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def define_parameters(*names)
+    thread_safe do
+      names.map do |name|
+        build_attribute(
+          name,
+          SmartCore::Types::Any,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_PRIVACY_MODE,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_FINALIZER,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_CAST_BEHAVIOUR,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_DYNAMIC_OPTIONS.dup
+        ).tap do |attribute|
+          prevent_option_overlap(attribute)
+        end
+      end.each do |attribute|
+        add_parameter(attribute)
+      end
+    end
+  end
+
+  # @param name [String, Symbol]
+  # @param type [String, Symbol, SmartCore::Types::Primitive]
+  # @param privacy [String, Symbol]
+  # @param finalize [String, Symbol, Proc]
+  # @param cast [Boolean]
+  # @param dynamic_options [Hash<Symbol,Any>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def define_option(name, type, privacy, finalize, cast, dynamic_options)
+    thread_safe do
+      attribute = build_attribute(name, type, privacy, finalize, cast, dynamic_options)
+      prevent_parameter_overlap(attribute)
+      add_option(attribute)
+    end
+  end
+
+  # @param names [Array<String, Symbol>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def define_options(*names)
+    thread_safe do
+      names.map do |name|
+        build_attribute(
+          name,
+          SmartCore::Types::Any,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_PRIVACY_MODE,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_FINALIZER,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_CAST_BEHAVIOUR,
+          SmartCore::Initializer::Attribute::Parameters::DEFAULT_DYNAMIC_OPTIONS.dup
+        ).tap do |attribute|
+          prevent_parameter_overlap(attribute)
+        end
+      end.each do |attribute|
+        add_option(attribute)
+      end
+    end
+  end
+
+  private
+
+  # @return [Class]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :klass
+
+  # @param name [String, Symbol]
+  # @param type [String, Symbol, SmartCore::Types::Primitive]
+  # @param privacy [String, Symbol]
+  # @param finalize [String, Symbol, Proc]
+  # @param cast [Boolean]
+  # @param dynamic_options [Hash<Symbol,Any>]
+  # @return [SmartCore::Initializer::Attribute]
+  #
+  # @api private
+  # @since 0.1.0
+  def build_attribute(name, type, privacy, finalize, cast, dynamic_options)
+    SmartCore::Initializer::Attribute::Factory.create(
+      name, type, privacy, finalize, cast, dynamic_options
+    )
+  end
+
+  # @param parameter [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_parameter(parameter)
+    klass.__params__ << parameter
+    klass.send(:attr_reader, parameter.name)
+    klass.send(parameter.privacy, parameter.name)
+  end
+
+  # @param option [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_option(option)
+    klass.__options__ << option
+    klass.send(:attr_reader, option.name)
+    klass.send(option.privacy, option.name)
+  end
+
+  # @param parameter [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_option_overlap(parameter)
+    if klass.__options__.include?(parameter)
+      raise(SmartCore::Initializer::OptionOverlapError, <<~ERROR_MESSAGE)
+        You have already defined option with name :#{parameter.name}
+      ERROR_MESSAGE
+    end
+  end
+
+  # @param option [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def prevent_parameter_overlap(option)
+    if klass.__params__.include?(option)
+      raise(SmartCore::Initializer::ParameterOverlapError, <<~ERROR_MESSAGE)
+        You have already defined parameter with name :#{option.name}
+      ERROR_MESSAGE
+    end
+  end
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def thread_safe(&block)
+    @lock.synchronize(&block)
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Initializer::Attribute::Factory
+  class << self
+    # @param name [String, Symbol]
+    # @param type [String, Symbol, SmartCore::Types::Primitive]
+    # @param privacy [String, Symbol]
+    # @param finalize [String, Symbol, Proc]
+    # @param cast [Boolean]
+    # @param dynamic_options [Hash<Symbol,Any>]
+    # @return [SmartCore::Initializer::Attribute]
+    #
+    # @api private
+    # @since 0.1.0
+    def create(name, type,  privacy, finalize, cast, dynamic_options)
+      name            = prepare_name_param(name)
+      type            = prepare_type_param(type)
+      privacy         = prepare_privacy_param(privacy)
+      finalize        = prepare_finalize_param(finalize)
+      cast            = prepare_cast_param(cast)
+      dynamic_options = prepare_dynamic_options_param(dynamic_options)
+
+      create_attribute(name, type, privacy, finalize, cast, dynamic_options)
+    end
+
+    private
+
+    # @param name [String, Symbol]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_name_param(name)
+      unless name.is_a?(String) || name.is_a?(Symbol)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute name should be a type of String or Symbol
+        ERROR_MESSAGE
+      end
+
+      name.to_s
+    end
+
+    # @param type [String, Symbol, SmartCore::Types::Primitive]
+    # @return [SmartCore::Types::Primitive]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_type_param(type)
+      unless type.is_a?(String) || type.is_a?(Symbol) || type.is_a?(SmartCore::Types::Primitive)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute type should be a type of String, Symbol or SmartCore::Types::Primitive
+        ERROR_MESSAGE
+      end
+
+      type
+    end
+
+    # @param cast [Boolean]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_cast_param(cast)
+      unless cast.is_a?(TrueClass) || cast.is_a?(FalseClass)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute cast should be a type of boolean
+        ERROR_MESSAGE
+      end
+
+      cast
+    end
+
+    # @param privacy [String, Symbol]
+    # @return [Symbol]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_privacy_param(privacy)
+      unless privacy.is_a?(String) || privacy.is_a?(Symbol)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute privacy should be a type of String or Symbol
+        ERROR_MESSAGE
+      end
+
+      SmartCore::Initializer::Attribute::Parameters::PRIVACY_MODES.fetch(privacy.to_sym) do
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Incorrect attribute privacy identifier "#{privacy}"
+        ERROR_MESSAGE
+      end
+    end
+
+    # @param finalize [String, Symbol, Proc]
+    # @return [SmartCore::Initializer::Attribute::Finalizer::AnonymousBlock/InstanceMethod]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_finalize_param(finalize)
+      unless finalize.is_a?(String) || finalize.is_a?(Symbol) || finalize.is_a?(Proc)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute finalizer should be a type of String, Symbol or Proc
+        ERROR_MESSAGE
+      end
+
+      SmartCore::Initializer::Attribute::Finalizer.create(finalize)
+    end
+
+    # @param dynamic_options [Hash<Symbol,Any>]
+    # @return [Hash<Symbol,Any>]
+    #
+    # @api private
+    # @since 0.1.0
+    def prepare_dynamic_options_param(dynamic_options)
+      # :nocov:
+      unless dynamic_options.is_a?(Hash)
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Attribute dynamic options should be a type of Hash
+        ERROR_MESSAGE
+      end
+      # :nocov:
+
+      dynamic_options
+    end
+
+    # @param name [String]
+    # @param type [SmartCore::Types::Primitive]
+    # @param privacy [Symbol]
+    # @param finalize [SmartCore::Initializer::Attribute::Finalizer::AnonymousBlock/InstanceMethod]
+    # @param cast [Boolean]
+    # @param dynamic_options [Hash<Symbol,String>]
+    # @return [SmartCore::Initializer::Attribute]
+    #
+    # @api private
+    # @since 0.1.0
+    def create_attribute(name, type, privacy, finalize, cast, dynamic_options)
+      SmartCore::Initializer::Attribute.new(name, type, privacy, finalize, cast, dynamic_options)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Initializer::Attribute::Finalizer
+  require_relative 'finalizer/instance_method'
+  require_relative 'finalizer/anonymous_block'
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.1.0
+  DEFAULT_FINALIZER = proc { |value| value }.freeze
+
+  class << self
+    # @param finalization_approach [String, Symbol, Proc]
+    # @return [SmartCore::Initializer::Attribute::Finalizer::InstanceMethod]
+    # @return [SmartCore::Initializer::Attribute::Finalizer::AnonymousBlock]
+    #
+    # @api private
+    # @since 0.1.0
+    def create(finalization_approach)
+      case finalization_approach
+      when String, Symbol
+        InstanceMethod.new(finalization_approach)
+      when Proc
+        AnonymousBlock.new(finalization_approach)
+      else
+        # :nocov:
+        raise(SmartCore::Initializer::ArgumentError, <<~ERROR_MESSAGE)
+          Finalization approach should be a type of Proc, Symbol or String'
+        ERROR_MESSAGE
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/smart_core/initializer/attribute/finalizer/anonymous_block.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# @pai private
+# @since 0.1.0
+class SmartCore::Initializer::Attribute::Finalizer::AnonymousBlock
+  # @param finalizer [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(finalizer)
+    @finalizer = finalizer
+  end
+
+  # @param value [Any]
+  # @param isntance [Any]
+  # @return [value]
+  #
+  # @pai private
+  # @since 0.1.0
+  def call(value, instance)
+    instance.instance_exec(value, &finalizer)
+  end
+
+  private
+
+  # @return [NilClass, Any]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :finalizer
+end

data/lib/smart_core/initializer/attribute/finalizer/instance_method.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# @pai private
+# @since 0.1.0
+class SmartCore::Initializer::Attribute::Finalizer::InstanceMethod
+  # @param finalizer [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(finalizer)
+    @finalizer = finalizer
+  end
+
+  # @param value [Any]
+  # @param instance [Any]
+  # @return [value]
+  #
+  # @pai private
+  # @since 0.1.0
+  def call(value, instance)
+    instance.send(finalizer, value)
+  end
+
+  private
+
+  # @return [NilClass, Any]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :finalizer
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class SmartCore::Initializer::Attribute::List
+  # @since 0.1.0
+  include Enumerable
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize
+    @attributes = {}
+    @lock = SmartCore::Engine::Lock.new
+  end
+
+  # @param attribute [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def add(attribute)
+    thread_safe { attributes[attribute.name] = attribute }
+  end
+  alias_method :<<, :add
+
+  # @param attribute [SmartCore::Initializer::Attribute]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def include?(attribute)
+    thread_safe { attributes.key?(attribute.name) }
+  end
+
+  # @param block [Block]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  def each(&block)
+    thread_safe do
+      block_given? ? attributes.values.each(&block) : attributes.values.each
+    end
+  end
+
+  private
+
+  # @return [Hash<String,SmartCore::Initializer::Attribute>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :attributes
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  def thread_safe(&block)
+    @lock.synchronize(&block)
+  end
+end