convenient_service 0.17.0 → 0.19.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]
-                #
-                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]
+                # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Status]
                 #
-                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,46 @@ 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 [String]
+                #
+                def printable_container
+                  Utils::Class.display_name(container.klass)
                 end
 
                 ##
+                # @api private
+                #
+                # @return [String]
+                #
+                def printable_service
+                  Utils::Class.display_name(service.klass)
+                end
+
+                ##
+                # @api private
+                #
                 # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
@@ -215,40 +222,43 @@ 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)
+                  @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.
+                # @return [Class]
                 #
-                def result
-                  convert_to_step_result(service_result)
+                def service_class
+                  service.klass
                 end
 
                 ##
-                # @return [String]
+                # @api private
                 #
-                def printable_service
-                  service.klass.to_s
+                # @return [Boolean]
+                #
+                def has_organizer?
+                  Utils.to_bool(organizer(raise_when_missing: false))
                 end
 
                 ##
-                # @return [Class]
+                # @api public
                 #
-                def service_class
-                  service.klass
+                # @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 +267,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 +306,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [void]
                 #
                 def define!
@@ -278,6 +317,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 +356,8 @@ module ConvenientService
                 end
 
                 ##
+                # @api private
+                #
                 # @return [Hash{Symbol => Object}]
                 #
                 def to_kwargs
@@ -292,10 +365,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 +399,19 @@ 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 {} if status.unsafe_not_success?
+                  return {} if outputs.none?
+
+                  unsafe_data.to_h
                 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,65 @@ 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]
-                    #
-                    # @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.
+                    # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Plugins::CanBeMethodStep::CanBeExecuted::Exceptions::MethodForStepIsNotDefined]
                     #
                     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]
+                    #
+                    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.
+                    #
+                    def own_method
+                      Utils.memoize_including_falsy_values(self, :@own_method) { Utils::Object.own_method(organizer, method_name, private: true) }
+                    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/exceptions.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveSteps
+        module Entities
+          class Step
+            module Plugins
+              module CanHaveFallbacks
+                module Exceptions
+                  class FallbackResultIsNotOverridden < ::ConvenientService::Exception
+                    ##
+                    # @param step [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
+                    # @param service [ConvenientService::Service]
+                    # @param status [Symbol]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(step:, service:, status:)
+                      message = <<~TEXT
+                        Neither `fallback_#{status}_result` nor `fallback_result` methods of `#{service.class}` are overridden, but the step is marked to be fallbacked.
+
+                        Either override one of those methods or remove the `fallback` option from the corresponding step definition in `#{step.container.klass}`.
+                      TEXT
+
+                      initialize(message)
+                    end
+                  end
+
+                  class MethodStepCanNotHaveFallback < ::ConvenientService::Exception
+                    ##
+                    # @param step [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(step:)
+                      message = <<~TEXT
+                        Method step can NOT have fallback.
+
+                        Either remove `fallback` option from step `:#{step.method}` in `#{step.container.klass}` or consider to refactor it into a service step.
+                      TEXT
+
+                      initialize(message)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end