convenient_service 0.17.0 → 0.18.0

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/concern/instance_methods.rb

@@ -16,34 +16,9 @@ module ConvenientService
                 include Support::Delegate
 
                 ##
-                # @return [Boolean]
-                #
-                delegate :success?, to: :result
-
-                ##
-                # @return [Boolean]
+                # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Status]
                 #
-                delegate :failure?, to: :result
-
-                ##
-                # @return [Boolean]
-                #
-                delegate :error?, to: :result
-
-                ##
-                # @return [Boolean]
-                #
-                delegate :not_success?, to: :result
-
-                ##
-                # @return [Boolean]
-                #
-                delegate :not_failure?, to: :result
-
-                ##
-                # @return [Boolean]
-                #
-                delegate :not_error?, to: :result
+                delegate :status, to: :result
 
                 ##
                 # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Data]
@@ -107,66 +82,62 @@ module ConvenientService
                 delegate :extra_kwargs, to: :params
 
                 ##
-                # @param args [Array<Object>]
-                # @param kwargs [Hash{Symbol => Object}]
-                # @return [void]
+                # @return [Boolean]
                 #
-                def initialize(*args, **kwargs)
-                  @args = args
-                  @kwargs = kwargs
-                end
+                delegate :success?, to: :result
 
                 ##
-                # @param other [Object] Can be any type.
-                # @return [Boolean, nil]
-                #
-                # @internal
-                #   TODO: Currently `==` does NOT compare `extra_kwargs`. Is it OK?
+                # @return [Boolean]
                 #
-                def ==(other)
-                  return unless other.instance_of?(self.class)
+                delegate :failure?, to: :result
 
-                  return false if service != other.service
-                  return false if inputs != other.inputs
-                  return false if outputs != other.outputs
-                  return false if index != other.index
-                  return false if container != other.container
-                  return false if organizer(raise_when_missing: false) != other.organizer(raise_when_missing: false)
+                ##
+                # @return [Boolean]
+                #
+                delegate :error?, to: :result
 
-                  true
-                end
+                ##
+                # @return [Boolean]
+                #
+                delegate :not_success?, to: :result
 
                 ##
                 # @return [Boolean]
                 #
-                def has_organizer?
-                  Utils.to_bool(organizer(raise_when_missing: false))
-                end
+                delegate :not_failure?, to: :result
 
                 ##
                 # @return [Boolean]
-                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
-                def has_reassignment?(name)
-                  outputs.any? { |output| output.reassignment?(name) }
-                end
+                delegate :not_error?, to: :result
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method, nil]
-                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                # @api private
                 #
-                def reassignment(name)
-                  outputs.find { |output| output.reassignment?(name) }
+                # @param args [Array<Object>]
+                # @param kwargs [Hash{Symbol => Object}]
+                # @return [void]
+                #
+                def initialize(*args, **kwargs)
+                  @args = args
+                  @kwargs = kwargs
                 end
 
                 ##
+                # @api private
+                #
                 # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Structs::Params]
                 #
+                # @internal
+                #   TODO: Direct specs.
+                #
                 def params
                   @params ||= resolve_params
                 end
 
                 ##
+                # @api private
+                #
                 # @return [ConvenientService::Service]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
@@ -184,6 +155,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api public
+                #
                 # @return [Array<ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method>]
                 #
                 def inputs
@@ -191,6 +164,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api public
+                #
                 # @return [Hash{Symbol => Object}]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
@@ -199,14 +174,28 @@ module ConvenientService
                 end
 
                 ##
+                # @api public
+                #
                 # @return [Hash{Symbol => Object}]
-                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer, ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepResultDataNotExistingDataAttribute]
                 #
                 def output_values
-                  @output_values ||= result.unsafe_data.to_h.slice(*outputs.map(&:key).map(&:to_sym))
+                  @output_values ||= calculate_output_values
                 end
 
                 ##
+                # @api public
+                #
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method, nil]
+                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                #
+                def reassignment(name)
+                  outputs.find { |output| output.reassignment?(name) }
+                end
+
+                ##
+                # @api private
+                #
                 # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
@@ -215,26 +204,15 @@ module ConvenientService
                 # @internal
                 #   IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
                 #
-                #   NOTE: `service_result` returns a foreign result that is later converted to own result by `convert_to_step_result` in `result`.
+                #   NOTE: `service_result` returns a foreign result that is later converted to own result by `HasResult` middleware.
                 #
                 def service_result
                   service.klass.result(**input_values)
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                # @api private
                 #
-                # @note `result` has middlewares.
-                #
-                # @internal
-                #   NOTE: Convents a foreign result received from `service_result` to own result.
-                #
-                def result
-                  convert_to_step_result(service_result)
-                end
-
-                ##
                 # @return [String]
                 #
                 def printable_service
@@ -242,6 +220,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [Class]
                 #
                 def service_class
@@ -249,6 +229,27 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
+                # @return [Boolean]
+                #
+                def has_organizer?
+                  Utils.to_bool(organizer(raise_when_missing: false))
+                end
+
+                ##
+                # @api public
+                #
+                # @return [Boolean]
+                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                #
+                def has_reassignment?(name)
+                  outputs.any? { |output| output.reassignment?(name) }
+                end
+
+                ##
+                # @api private
+                #
                 # @return [void]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
@@ -257,6 +258,33 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
+                # @return [Boolean]
+                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::MethodHasNoOrganizer]
+                #
+                # @internal
+                #   TODO: Create `OutputMethod`. Move `save` into it.
+                #
+                def save_outputs_in_organizer!
+                  output_values.each_pair { |key, value| organizer.internals.cache.scope(:step_output_values).write(key, value) }
+
+                  true
+                end
+
+                ##
+                # @api private
+                #
+                # @param organizer [ConvenientService::Service]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
+                #
+                def with_organizer(organizer)
+                  copy(overrides: {kwargs: {organizer: organizer}})
+                end
+
+                ##
+                # @api private
+                #
                 # @return [void]
                 # @raise [ConvenientService::Error]
                 #
@@ -269,6 +297,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [void]
                 #
                 def define!
@@ -278,6 +308,38 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
+                # @param other [Object] Can be any type.
+                # @return [Boolean, nil]
+                #
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if service != other.service
+                  return false if inputs != other.inputs
+                  return false if outputs != other.outputs
+                  return false if index != other.index
+                  return false if container != other.container
+                  return false if organizer(raise_when_missing: false) != other.organizer(raise_when_missing: false)
+                  return false if extra_kwargs != other.extra_kwargs
+
+                  true
+                end
+
+                ##
+                # @return [String]
+                #
+                # @internal
+                #   TODO: Remove `printable_service` completely. Leave only `to_s`.
+                #
+                def to_s
+                  printable_service
+                end
+
+                ##
+                # @api private
+                #
                 # @return [Array<Object>]
                 #
                 def to_args
@@ -285,6 +347,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [Hash{Symbol => Object}]
                 #
                 def to_kwargs
@@ -292,10 +356,12 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [ConveninentService::Support::Arguments]
                 #
                 def to_arguments
-                  Support::Arguments.new(service, **kwargs.merge(in: inputs, out: outputs, index: index, container: container, organizer: organizer(raise_when_missing: false)))
+                  Support::Arguments.new(service, **kwargs.merge(in: inputs, out: outputs, index: index, container: container, organizer: organizer(raise_when_missing: false), **extra_kwargs))
                 end
 
                 private
@@ -324,11 +390,20 @@ module ConvenientService
                 end
 
                 ##
-                # @param result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                # @return [Hash{Symbol => Object}]
+                # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer, ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepResultDataNotExistingAttribute]
                 #
-                def convert_to_step_result(result)
-                  result.copy(overrides: {kwargs: {step: self, service: organizer}})
+                # @internal
+                #   TODO: Commands instead of private methods.
+                #   IMPORTANT: `status.unsafe_success?` is used instead of `success?` or `result.status?` in order to NOT mark result as checked.
+                #   TODO: Create `OutputMethod`. Move `validate_as_output_for_result` into it.
+                #
+                def calculate_output_values
+                  return {} unless status.unsafe_success?
+
+                  outputs.each { |output| ::ConvenientService.raise Exceptions::StepResultDataNotExistingAttribute.new(step: self, key: output.key.to_sym) unless unsafe_data.has_attribute?(output.key.to_sym) }
+
+                  outputs.reduce({}) { |values, output| values.merge(output.name.to_sym => unsafe_data[output.key.to_sym]) }
                 end
 
                 ##

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/exceptions.rb

@@ -18,6 +18,25 @@ module ConvenientService
                   initialize(message)
                 end
               end
+
+              class StepResultDataNotExistingAttribute < ::ConvenientService::Exception
+                ##
+                # @param key [Symbol]
+                # @param step [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
+                # @return [void]
+                #
+                def initialize_with_kwargs(key:, step:)
+                  message = <<~TEXT
+                    Step `#{step.printable_service}` result does NOT return `:#{key}` data attribute.
+
+                    Maybe there is a typo in `out` definition?
+
+                    Or `success` of `#{step.printable_service}` accepts a wrong key?
+                  TEXT
+
+                  initialize(message)
+                end
+              end
             end
           end
         end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/{can_be_result_step → can_be_method_step}/can_be_executed/exceptions.rb

@@ -7,7 +7,7 @@ module ConvenientService
         module Entities
           class Step
             module Plugins
-              module CanBeResultStep
+              module CanBeMethodStep
                 module CanBeExecuted
                   module Exceptions
                     class MethodForStepIsNotDefined < ::ConvenientService::Exception

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_method_step/can_be_executed/middleware.rb

@@ -10,19 +10,79 @@ module ConvenientService
               module CanBeMethodStep
                 module CanBeExecuted
                   class Middleware < MethodChainMiddleware
-                    intended_for :service_result, entity: :step
+                    intended_for :result, entity: :step
 
                     ##
                     # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Plugins::CanBeResultStep::CanBeExecuted::Exceptions::MethodForStepIsNotDefined]
+                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Plugins::CanBeMethodStep::CanBeExecuted::Exceptions::MethodForStepIsNotDefined]
                     #
                     # @internal
-                    #   NOTE: `kwargs` are intentionally NOT passed to `object.__send__(method)`, since all the corresponding methods are available inside `entity.organizer.__send__(entity.method)` body.
+                    #   NOTE: `kwargs` are intentionally NOT passed to `own_method.call`, since all the corresponding methods are available inside `own_method` body.
                     #
                     def next(...)
                       return chain.next(...) unless entity.method_step?
 
-                      entity.organizer.__send__(entity.method)
+                      ::ConvenientService.raise Exceptions::MethodForStepIsNotDefined.new(service_class: organizer.class, method_name: method_name) unless own_method
+
+                      call_method(own_method)
+                    end
+
+                    private
+
+                    ##
+                    # @param method [Method]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    #
+                    # @internal
+                    #   TODO: Add specs.
+                    #
+                    def call_method(method)
+                      params = Support::MethodParameters.new(method.parameters)
+
+                      return method.call(**input_values) if params.has_rest_kwargs?
+
+                      return method.call(**input_values.slice(*params.named_kwargs_keys)) if params.named_kwargs_keys.any?
+
+                      method.call
+                    end
+
+                    ##
+                    # @return [Method, nil]
+                    #
+                    # @internal
+                    #   TODO: A possible bottleneck. Should be removed if receives negative feedback.
+                    #
+                    #   NOTE: `own_method.bind(organizer).call` is logically the same as `own_method.bind_call(organizer)`.
+                    #   - https://ruby-doc.org/core-2.7.1/UnboundMethod.html#method-i-bind_call
+                    #   - https://blog.saeloun.com/2019/10/17/ruby-2-7-adds-unboundmethod-bind_call-method.html
+                    #
+                    def own_method
+                      method = Utils::Module.get_own_instance_method(organizer.class, method_name, private: true)
+
+                      return unless method
+
+                      method.bind(organizer)
+                    end
+
+                    ##
+                    # @return [ConvenientService::Service]
+                    #
+                    def organizer
+                      @organizer ||= entity.organizer
+                    end
+
+                    ##
+                    # @return [Symbol]
+                    #
+                    def method_name
+                      @method_name ||= entity.method
+                    end
+
+                    ##
+                    # @return [Hash{Symbol => Object}]
+                    #
+                    def input_values
+                      @input_values ||= entity.input_values
                     end
                   end
                 end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_method_step/can_be_executed.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require_relative "can_be_executed/exceptions"
 require_relative "can_be_executed/middleware"

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_method_step/concern.rb

@@ -25,6 +25,13 @@ module ConvenientService
                     def method_step?
                       Utils.to_bool(method)
                     end
+
+                    ##
+                    # @return [Boolean]
+                    #
+                    def result_step?
+                      method_step? && method == :result
+                    end
                   end
                 end
               end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_have_alternative_steps.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "can_have_alternative_steps/middleware"

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_have_fallbacks/concern.rb

@@ -39,52 +39,6 @@ module ConvenientService
                     def fallback_step?
                       fallback_true_step? || fallback_failure_step? || fallback_error_step?
                     end
-
-                    ##
-                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
-                    #
-                    # @note `service_fallback_failure_result` has middlewares.
-                    #
-                    # @internal
-                    #   IMPORTANT: `service.klass.fallback_failure_result(**input_values)` is the reason, why services should have only kwargs as arguments.
-                    #   TODO: Extract `StepDefinition`. This way `has_organizer?` check can be avoided completely.
-                    #
-                    def service_fallback_failure_result
-                      service.klass.fallback_failure_result(**input_values)
-                    end
-
-                    ##
-                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
-                    # @note `fallback_failure_result` has middlewares.
-                    #
-                    def fallback_failure_result
-                      convert_to_step_result(service_fallback_failure_result)
-                    end
-
-                    ##
-                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
-                    #
-                    # @note `service_fallback_error_result` has middlewares.
-                    #
-                    # @internal
-                    #   IMPORTANT: `service.klass.fallback_error_result(**input_values)` is the reason, why services should have only kwargs as arguments.
-                    #   TODO: Extract `StepDefinition`. This way `has_organizer?` check can be avoided completely.
-                    #
-                    def service_fallback_error_result
-                      service.klass.fallback_error_result(**input_values)
-                    end
-
-                    ##
-                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
-                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
-                    # @note `fallback_error_result` has middlewares.
-                    #
-                    def fallback_error_result
-                      convert_to_step_result(service_fallback_error_result)
-                    end
                   end
                 end
               end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_have_fallbacks/middleware.rb

@@ -21,9 +21,9 @@ module ConvenientService
                     when :success
                       result
                     when :failure
-                      fallback_failure_step? ? entity.fallback_failure_result(...) : result
+                      fallback_failure_step? ? fallback_failure_result(...) : result
                     when :error
-                      fallback_error_step? ? entity.fallback_error_result(...) : result
+                      fallback_error_step? ? fallback_error_result(...) : result
                     end
                   end
 
@@ -63,6 +63,30 @@ module ConvenientService
                   def fallback_true_status
                     middleware_arguments.kwargs.fetch(:fallback_true_status) { :failure }
                   end
+
+                  ##
+                  # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                  # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                  #
+                  # @internal
+                  #   IMPORTANT: `service.klass.fallback_failure_result(**input_values)` is the reason, why services should have only kwargs as arguments.
+                  #   TODO: `entity.service.fallback_failure_result`.
+                  #
+                  def fallback_failure_result
+                    entity.service.klass.fallback_failure_result(**entity.input_values)
+                  end
+
+                  ##
+                  # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                  # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                  #
+                  # @internal
+                  #   IMPORTANT: `service.klass.fallback_error_result(**input_values)` is the reason, why services should have only kwargs as arguments.
+                  #   TODO: `entity.service.fallback_error_result`.
+                  #
+                  def fallback_error_result
+                    entity.service.klass.fallback_error_result(**entity.input_values)
+                  end
                 end
               end
             end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_have_parent_result/middleware.rb

@@ -11,8 +11,20 @@ module ConvenientService
                 class Middleware < MethodChainMiddleware
                   intended_for :result, entity: :step
 
+                  ##
+                  # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                  # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
+                  #
+                  # @internal
+                  #   IMPORTANT: `CanHaveParentResult` middleware MUST be placed after `HasResult` middleware.
+                  #
+                  #   NOTE: `result` at the moment of this middleware is still a `service_result` (or `method_result`). It is only later converted to `step_result` by `HasResult` middleware.
+                  #   That is why `result` is used as `parent` here.
+                  #
                   def next(...)
-                    chain.next(...).copy(overrides: {kwargs: {parent: entity.service_result}})
+                    result = chain.next(...)
+
+                    result.copy(overrides: {kwargs: {parent: result}})
                   end
                 end
               end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/{can_be_result_step → has_result}/concern.rb

@@ -7,16 +7,20 @@ module ConvenientService
         module Entities
           class Step
             module Plugins
-              module CanBeResultStep
+              module HasResult
                 module Concern
                   include Support::Concern
 
                   instance_methods do
                     ##
-                    # @return [Boolean]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                     #
-                    def result_step?
-                      method_step? && method == :result
+                    # @internal
+                    #   TODO: `service.result`.
+                    #
+                    def result
+                      service_result
                     end
                   end
                 end