smart_core 0.4.0 → 0.5.0

data/lib/smart_core/initializer/instance_builder.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::InstanceBuilder
+  class << self
+    # @param processed_object [Any]
+    # @param processed_klass [Class]
+    # @param parameters [Array<Any>]
+    # @param options [Hash<Symbol,Any>]
+    # @return [Any] Fully allocated processed_object
+    #
+    # @api private
+    # @since 0.5.0
+    def call(processed_object, processed_klass, parameters, options)
+      new(processed_object, processed_klass, parameters, options).call
+    end
+  end
+
+  # @param processed_object [Any]
+  # @param processed_klass [Class]
+  # @param parameters [Array<Any>]
+  # @param options [Hash<Symbol,Any>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(processed_object, processed_klass, parameters, options)
+    @processed_object = processed_object
+    @processed_klass = processed_klass
+    @parameters = parameters
+    @options = options
+  end
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def call
+    processed_object.tap do
+      prevent_parameters_incomparability
+      initialize_parameters
+      initialize_options
+      call_original_methods
+      invoke_additional_initialization_steps
+    end
+  end
+
+  private
+
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :processed_object
+
+  # @return [Class]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :processed_klass
+
+  # @return [Array<Any>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :parameters
+
+  # @return [Hash<Symbol,Any>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :options
+
+  # An array of the required option attribute names (parameters without default values)
+  #
+  # @return [Array<Symbol>]
+  #
+  # @api private
+  # @since 0.5.0
+  def required_options
+    processed_klass.__options__.each.reject(&:has_default_value?).map(&:name)
+  end
+
+  # @return [Integer]
+  #
+  # @api private
+  # @since 0.5.0
+  def required_attributes_count
+    processed_klass.__params__.size
+  end
+
+  # @return [void]
+  #
+  # @raise [SmartCore::Initializer::AttributeError]
+  # @raise [SmartCore::Initializer::ParameterError]
+  # @raise [SmartCore::Initializer::OptionError]
+  #
+  # @api private
+  # @since 0.5.0
+  def prevent_parameters_incomparability
+    raise(
+      SmartCore::Initializer::ParameterError,
+      "Wrong number of parameters " \
+      "(given #{parameters.size}, expected #{required_attributes_count})"
+    ) unless parameters.size == required_attributes_count
+
+    missing_options = required_options.reject { |option| options.key?(option) }
+
+    raise(
+      SmartCore::Initializer::OptionError,
+      "Missing options: :#{missing_options.join(', :')}"
+    ) unless missing_options.empty?
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize_parameters
+    parameter_objects = processed_klass.__params__
+    parameter_pairs   = Hash[parameter_objects.zip(parameters)]
+
+    parameter_pairs.each_pair do |parameter_object, parameter_value|
+      parameter_object.validate_value_type!(parameter_value)
+      final_parameter_value = parameter_object.finalize(parameter_value, processed_object)
+      processed_object.instance_variable_set("@#{parameter_object.name}", final_parameter_value)
+    end
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize_options
+    processed_klass.__options__.each do |option|
+      option_name  = option.name
+      option_value = options.fetch(option_name) { option.default_value }.tap do |value|
+        option.validate_value_type!(value)
+      end
+      final_option_value = option.finalize(option_value, processed_object)
+
+      processed_object.instance_variable_set("@#{option_name}", final_option_value)
+    end
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def invoke_additional_initialization_steps
+    processed_klass.__initialization_extensions__.each do |extension|
+      extension.call(processed_object)
+    end
+  end
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def call_original_methods
+    processed_object.send(:initialize, *parameters, **options)
+  end
+end

data/lib/smart_core/initializer/type.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::Type
+  # @return [String]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :name
+
+  # @name [Symbol, String]
+  # @param checker [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(name, checker)
+    unless name.is_a?(String) || name.is_a?(Symbol)
+      raise(SmartCore::Initializer::ArgumentError, 'Type name should be a symbol or a string')
+    end
+
+    unless checker.is_a?(Proc)
+      raise(SmartCore::Initializer::ArgumentError, 'Checker should be a proc')
+    end
+
+    @name = name.to_sym
+    @checker = checker
+  end
+
+  # @param value [Any]
+  # @return [Boolean]
+  #
+  # @raise [SmartCore::Initializer::TypeError]
+  #
+  # @api private
+  # @since 0.5.0
+  def comparable?(value)
+    checker.call(value)
+  end
+
+  private
+
+  # @return [Proc]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :checker
+end

data/lib/smart_core/initializer/type_set.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Initializer::TypeSet
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize
+    @types = {}
+  end
+
+  # @param name [String, Symbol]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.5.0
+  def has_type?(name)
+    types.key?(name)
+  end
+
+  # @param name [String, Symbol]
+  # @param checker [Proc]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def register(name, checker)
+    type = SmartCore::Initializer::Type.new(name, checker)
+    types[type.name] = type
+  end
+
+  # @param name [String, Symbol]
+  # @return [SmartCore::Initializer::Type]
+  #
+  # @api private
+  # @since 0.5.0
+  def resolve(name)
+    types.fetch(name.to_sym)
+  rescue KeyError
+    raise SmartCore::Initializer::UnregisteredTypeError, "type :#{name} is not registered!"
+  end
+
+  private
+
+  # @return [Hash<Symbol,SmartCore::Initializer::Type>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :types
+end

data/lib/smart_core/initializer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.5.0
+module SmartCore::Initializer
+  require_relative 'initializer/exceptions'
+  require_relative 'initializer/attribute'
+  require_relative 'initializer/attribute_set'
+  require_relative 'initializer/attribute_definer'
+  require_relative 'initializer/extension'
+  require_relative 'initializer/extension_set'
+  require_relative 'initializer/extension_definer'
+  require_relative 'initializer/instance_builder'
+  require_relative 'initializer/type'
+  require_relative 'initializer/type_set'
+  require_relative 'initializer/initialization_dsl'
+  require_relative 'initializer/instance_attribute_accessing'
+
+  @__type_set__ = SmartCore::Initializer::TypeSet.new
+  # TODO: convertable attributes and converters (in typeset manner)
+
+  class << self
+    # @param child_klass [Class]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.5.0
+    def included(child_klass)
+      child_klass.include(InitializationDSL)
+      child_klass.include(InstanceAttributeAccessing)
+    end
+
+    # @param name [String, Symbol]
+    # @param checker [Block]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.5.0
+    def register_type(name, &checker)
+      types.register(name, checker)
+    end
+
+    # @param name [String, Symbol]
+    # @return [SmartCore::Initializer::Type]
+    #
+    # @api private
+    # @since 0.5.0
+    def get_type(name)
+      types.resolve(name)
+    end
+
+    # @return [SmartCore::Initializer::TypeSet]
+    #
+    # @api private
+    # @since 0.5.0
+    def types
+      @__type_set__
+    end
+  end
+
+  # @return [void]
+  #
+  # @api public
+  # @since 0.5.0
+  def initialize(*, **); end
+
+  # @since 0.5.0
+  register_type(:array) { |value| value.is_a?(Array) }
+  # @since 0.5.0
+  register_type(:hash) { |value| value.is_a?(Hash) }
+  # @since 0.5.0
+  register_type(:string) { |value| value.is_a?(String) }
+  # @since 0.5.0
+  register_type(:integer) { |value| value.is_a?(Integer) }
+  # @since 0.5.0
+  register_type(:float) { |value| value.is_a?(Float) }
+  # @since 0.5.0
+  register_type(:proc) { |value| value.is_a?(Proc) }
+  # @since 0.5.0
+  register_type(:numeric) { |value| value.is_a?(Numeric) }
+  # @since 0.5.0
+  register_type(:big_decimal) { |value| value.is_a?(BigDecimal) }
+  # @since 0.5.0
+  register_type(:class) { |value| value.is_a?(Class) }
+  # @since 0.5.0
+  register_type(:boolean) { |value| value.is_a?(TrueClass) || value.is_a?(FalseClass) }
+  # @since 0.5.0
+  register_type(:__any__) { true }
+end

data/lib/smart_core/injector.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.5.0
+module SmartCore::Injector
+end

data/lib/smart_core/operation/exceptions.rb

@@ -3,7 +3,7 @@
 class SmartCore::Operation
   # @api public
   # @since 0.2.0
-  Error = Class.new(StandardError)
+  Error = Class.new(SmartCore::Error)
 
   # @api public
   # @since 0.3.0
@@ -27,27 +27,11 @@ class SmartCore::Operation
 
   # @api public
   # @since 0.2.0
-  ArgumentError = Class.new(::ArgumentError)
-
-  # @api public
-  # @since 0.2.0
-  ParameterError = Class.new(ArgumentError)
-
-  # @api public
-  # @since 0.2.0
-  ParamOverlapError = Class.new(ParameterError)
-
-  # @api public
-  # @since 0.2.0
-  OptionError = Class.new(ArgumentError)
-
-  # @api public
-  # @since 0.2.0
-  OptionOverlapError = Class.new(OptionError)
+  IncorrectAttributeNameError = Class.new(Error)
 
   # @api public
-  # @since 0.2.0
-  IncorrectAttributeNameError = Class.new(Error)
+  # @since 0.5.0
+  IncorrectStepNameError = Class.new(Error)
 
   # @api public
   # @since 0.2.0

data/lib/smart_core/operation/instance_builder.rb

@@ -1,49 +1,34 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.2.0
+# @since 0.5.0
 class SmartCore::Operation::InstanceBuilder
   class << self
-    # @param operation_object [SmartCore::Operation]
-    # @param operation_klass [Class<SmartCore::Operation>]
-    # @param parameters [Array<Any>]
-    # @param options [Hash<Symbol,Any>]
-    # @return [SmartCore::Operation]
+    # @param operation [SmartCore::Operation]
+    # @return [void]
     #
     # @api private
-    # @since 0.2.0
-    def call(operation_object, operation_klass, parameters, options)
-      new(operation_object, operation_klass, parameters, options).call
+    # @since 0.5.0
+    def call(operation)
+      new(operation).call
     end
   end
 
-  # @param operation_object [SmartCore::Operation]
-  # @param operation_klass [Class<SmartCore::Operation>]
-  # @param parameters [Array<Any>]
-  # @param options [Hash<Symbol,Any>]
+  # @param operation [SmartCore::Operation]
   # @return [void]
   #
   # @api private
-  # @since 0.2.0
-  def initialize(operation_object, operation_klass, parameters, options)
-    @operation_object = operation_object
-    @operation_klass = operation_klass
-    @parameters = parameters
-    @options = options
+  # @since 0.5.0
+  def initialize(operation)
+    @operation = operation
   end
 
-  # @return [SmartCore::Operation]
+  # @return [void]
   #
   # @api private
-  # @since 0.2.0
+  # @since 0.5.0
   def call
-    operation_object.tap do
-      prevent_parameters_incomparability
-      initialize_parameters
-      initialize_options
-      call_original_methods
-      make_operation_caller_yieldable
-    end
+    make_operation_caller_yieldable
   end
 
   private
@@ -51,108 +36,15 @@ class SmartCore::Operation::InstanceBuilder
   # @return [SmartCore::Operation]
   #
   # @api private
-  # @since 0.2.0
-  attr_reader :operation_object
-
-  # @return [Class<SmartCore::Operation>]
-  #
-  # @api private
-  # @since 0.2.0
-  attr_reader :operation_klass
-
-  # @return [Array<Any>]
-  #
-  # @api private
-  # @since 0.2.0
-  attr_reader :parameters
-
-  # @return [Hash<Symbol,Any>]
-  #
-  # @api private
-  # @since 0.2.0
-  attr_reader :options
-
-  # An array of the required option attribute names (parameters without default values)
-  #
-  # @return [Array<Symbol>]
-  #
-  # @api private
-  # @since 0.2.0
-  def required_options
-    operation_klass.__options__.each.reject(&:has_default_value?).map(&:name)
-  end
-
-  # @return [Integer]
-  #
-  # @api private
-  # @since 0.2.0
-  def required_attributes_count
-    operation_klass.__params__.size
-  end
-
-  # @return [void]
-  #
-  # @raise [SmartCore::Operation::AttributeError]
-  # @raise [SmartCore::Operation::ParameterError]
-  # @raise [SmartCore::Operation::OptionError]
-  #
-  # @api private
-  # @since 0.2.0
-  def prevent_parameters_incomparability
-    raise(
-      SmartCore::Operation::ParameterError,
-      "Wrong number of parameters " \
-      "(given #{parameters.size}, expected #{required_attributes_count})"
-    ) unless parameters.size == required_attributes_count
-
-    missing_options = required_options.reject { |option| options.key?(option) }
-
-    raise(
-      SmartCore::Operation::OptionError,
-      "Missing options: :#{missing_options.join(', :')}"
-    ) unless missing_options.empty?
-  end
-
-  # @return [void]
-  #
-  # @api private
-  # @since 0.2.0
-  def initialize_parameters
-    parameter_names = operation_klass.__params__.map(&:name)
-    parameter_pairs = Hash[parameter_names.zip(parameters)]
-
-    parameter_pairs.each_pair do |parameter_name, parameter_value|
-      operation_object.instance_variable_set("@#{parameter_name}", parameter_value)
-    end
-  end
-
-  # @return [void]
-  #
-  # @api private
-  # @since 0.2.0
-  def initialize_options
-    operation_klass.__options__.each do |option|
-      option_name  = option.name
-      option_value = options.fetch(option_name) { option.default_value }
-
-      operation_object.instance_variable_set("@#{option_name}", option_value)
-    end
-  end
-
-  # @return [void]
-  #
-  # @api private
-  # @since 0.2.0
-  def call_original_methods
-    operation_object.send(:initialize, *parameters, **options)
-  end
+  # @since 0.5.0
+  attr_reader :operation
 
   # @return [void]
   #
   # @api private
   # @since 0.2.0
   def make_operation_caller_yieldable
-    operation_object.singleton_class.prepend(Module.new do
+    operation.singleton_class.prepend(Module.new do
       def call
         super.tap { |result| yield(result) if block_given? }
       rescue SmartCore::Operation::FatalError => error

data/lib/smart_core/operation/state.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Operation::State
+  # TODO: think about it
+end

data/lib/smart_core/operation/step.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Operation::Step
+  # @return [String, Symbol]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :method_name
+
+  # @return [Hash<Symbol,Any>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :options
+
+  # @param method_name [String, Symbol]
+  # @param options [Hash<Symbol,Any>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize(method_name, **options)
+    unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+      raise(
+        SmartCore::Operation::IncorrectStepNameError,
+        'Step name should be a symbol or a string'
+      )
+    end
+
+    @method_name = method_name.to_sym
+    @options = options # TODO: support for another operations
+  end
+
+  # @return [SmartCore::Operation::Step]
+  #
+  # @api private
+  # @since 0.5.0
+  def dup
+    self.class.new(method_name, **options)
+  end
+end

data/lib/smart_core/operation/step_set.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.5.0
+class SmartCore::Operation::StepSet
+  # @since 0.5.0
+  include Enumerable
+
+  # @return [Array<SmartCore:::Operation::Step>]
+  #
+  # @api private
+  # @since 0.5.0
+  attr_reader :steps
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def initialize
+    @steps = []
+    @access_lock = Mutex.new
+  end
+
+  # @param step [SmartCore::Operation::Step]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.5.0
+  def add_step(step)
+    thread_safe { steps << step }
+  end
+  alias_method :<<, :add_step
+
+  # @param step_set [SmartCore::Operation::Step]
+  # @return [void]
+  #
+  # @api private
+  # @sinec 0.5.0
+  def concat(step_set)
+    thread_safe { steps.concat(step_set.dup.steps) }
+  end
+
+  # @retun [SmartCore::Operation::StepSet]
+  #
+  # @api private
+  # @since 0.5.0
+  def dup
+    thread_safe do
+      self.class.new.tap do |duplicate|
+        steps.each { |step| duplicate.add_step(step.dup) }
+      end
+    end
+  end
+
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.5.0
+  def each(&block)
+    thread_safe { block_given? ? steps.each(&block) : steps.each }
+  end
+
+  private
+
+  # @param block [Proc]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.5.0
+  def thread_safe(&block)
+    @access_lock.synchronize(&block)
+  end
+end