convenient_service 0.5.0 → 0.7.0

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/has_step/to_kwargs.rb

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

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/has_step.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "has_step/concern"
+require_relative "has_step/initialize"
+require_relative "has_step/to_kwargs"

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins.rb

@@ -3,6 +3,8 @@
 require_relative "plugins/can_recalculate_result"
 require_relative "plugins/has_jsend_status_and_attributes"
 require_relative "plugins/has_inspect"
+require_relative "plugins/has_step"
+require_relative "plugins/can_have_parent_result"
 require_relative "plugins/has_result_short_syntax"
 require_relative "plugins/marks_result_status_as_checked"
 require_relative "plugins/raises_on_not_checked_result_status"

data/lib/convenient_service/service/plugins/has_result_method_steps.rb

@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 
-require_relative "has_result_method_steps/errors"
 require_relative "has_result_method_steps/middleware"
-require_relative "has_result_method_steps/services"

data/lib/convenient_service/service/plugins/has_result_steps/concern.rb

@@ -8,6 +8,9 @@ module ConvenientService
           include Support::Concern
 
           instance_methods do
+            ##
+            # @return [Array<ConvenientService::Service::Plugins::HasResultSteps::Entities::Step>]
+            #
             def steps
               internals.cache.fetch(:steps) do
                 self.class
@@ -18,21 +21,37 @@ module ConvenientService
             end
 
             ##
-            # TODO: Create for callbacks.
+            # Returns step by index.
+            # Returns `nil` when index is out of range.
+            #
+            # @param index [Integer]
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::Step]
             #
-            #   def step(step_result)
-            #     step_result
-            #   end
+            # @note This method was initially designed as a hook (callback trigger).
+            # @see ConvenientService::Service::Plugins::HasResultSteps::Middleware#next
             #
+            def step(index)
+              steps[index]
+            end
           end
 
           class_methods do
+            ##
+            # Registers a step (step definition).
+            #
+            # @param args [Array]
+            # @param kwargs [Hash]
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::Step]
+            #
             def step(*args, **kwargs)
               step_class.new(*args, **kwargs.merge(container: self))
                 .tap { |step_instance| steps << step_instance }
             end
 
             ##
+            # @param value [Object] Can be any type.
+            # @return [ConvenientService::Support::RawValue]
+            #
             # Allows to pass a value to `in` method without its intermediate processing.
             # @see https://marian13.github.io/convenient_service_docs/basics/step_to_result_translation_table
             #
@@ -41,14 +60,31 @@ module ConvenientService
             #   # that is converted to the following service invocation:
             #   AssertFeatureEnabled.result(name: :chat_v2)
             #
+            # @param value [Object] Can be any type.
+            # @return [ConvenientService::Support::RawValue]
+            #
             def raw(value)
               Support::RawValue.wrap(value)
             end
 
+            ##
+            # @param method_name [String, Symbol]
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::Method::Entities::Values::Reassignment]
+            #
+            def reassign(method_name)
+              Entities::Method::Entities::Values::Reassignment.new(method_name)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::StepCollection]
+            #
             def steps
               @steps ||= Entities::StepCollection.new
             end
 
+            ##
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::Step]
+            #
             def step_class
               @step_class ||= Commands::CreateStepClass.call(service_class: self)
             end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method.rb

@@ -7,6 +7,9 @@ module ConvenientService
         module Entities
           class Method
             module Commands
+              ##
+              # TODO: Abstract factory.
+              #
               class CastMethod < Support::Command
                 attr_reader :other, :options
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_caller.rb

@@ -8,7 +8,7 @@ module ConvenientService
           class Method
             module Commands
               ##
-              # TODO: Replace `CastMethodKey`, `CastMethodName`, `CastMethodCaller` by declarative caster?
+              # TODO: Abstract factory.
               #
               class CastMethodCaller < Support::Command
                 attr_reader :other, :options
@@ -23,6 +23,7 @@ module ConvenientService
                   when ::Symbol then cast_symbol
                   when ::String then cast_string
                   when ::Hash then cast_hash
+                  when Entities::Values::Reassignment then cast_reassignment
                   when Method then cast_method
                   end
                 end
@@ -37,6 +38,10 @@ module ConvenientService
                   Entities::Callers::Usual.new(other)
                 end
 
+                def cast_reassignment
+                  Entities::Callers::Reassignment.new(other)
+                end
+
                 def cast_hash
                   return unless other.keys.one?
 
@@ -51,6 +56,8 @@ module ConvenientService
                     Entities::Callers::Proc.new(value)
                   when Support::RawValue
                     Entities::Callers::Raw.new(value)
+                  when Entities::Values::Reassignment
+                    Entities::Callers::Reassignment.new(value)
                   end
                 end
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_direction.rb

@@ -7,6 +7,9 @@ module ConvenientService
         module Entities
           class Method
             module Commands
+              ##
+              # TODO: Abstract factory.
+              #
               class CastMethodDirection < Support::Command
                 attr_reader :other, :options
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_key.rb

@@ -8,7 +8,7 @@ module ConvenientService
           class Method
             module Commands
               ##
-              # TODO: Replace `CastMethodKey`, `CastMethodName`, `CastMethodCaller` by declarative caster?
+              # TODO: Abstract factory.
               #
               class CastMethodKey < Support::Command
                 attr_reader :other, :options
@@ -26,6 +26,7 @@ module ConvenientService
                   when ::Symbol then cast_symbol
                   when ::String then cast_string
                   when ::Hash then cast_hash
+                  when Entities::Values::Reassignment then cast_reassignment
                   when Method then cast_method
                   end
                 end
@@ -40,6 +41,10 @@ module ConvenientService
                   Entities::Key.new(other)
                 end
 
+                def cast_reassignment
+                  Entities::Key.new(other.to_sym)
+                end
+
                 def cast_hash
                   return unless other.keys.one?
 
@@ -55,6 +60,8 @@ module ConvenientService
                     Entities::Key.new(key)
                   when Support::RawValue
                     Entities::Key.new(key)
+                  when Entities::Values::Reassignment
+                    Entities::Key.new(key)
                   end
                 end
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_name.rb

@@ -7,8 +7,8 @@ module ConvenientService
         module Entities
           class Method
             module Commands
-              ##
-              # TODO: Replace `CastMethodKey`, `CastMethodName`, `CastMethodCaller` by declarative caster?
+              #
+              # TODO: Abstract factory.
               #
               class CastMethodName < Support::Command
                 attr_reader :other, :options
@@ -26,6 +26,7 @@ module ConvenientService
                   when ::Symbol then cast_symbol
                   when ::String then cast_string
                   when ::Hash then cast_hash
+                  when Entities::Values::Reassignment then cast_reassignment
                   when Method then cast_method
                   end
                 end
@@ -40,6 +41,10 @@ module ConvenientService
                   Entities::Name.new(other)
                 end
 
+                def cast_reassignment
+                  Entities::Name.new(other.to_sym)
+                end
+
                 def cast_hash
                   return unless other.keys.one?
 
@@ -55,12 +60,11 @@ module ConvenientService
                     Entities::Name.new(key)
                   when Support::RawValue
                     Entities::Name.new(key)
+                  when Entities::Values::Reassignment
+                    Entities::Name.new(value.to_sym)
                   end
                 end
 
-                ##
-                # TODO: Specs.
-                #
                 def cast_method
                   other.name.copy
                 end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/define_method_in_container.rb

@@ -30,9 +30,9 @@ module ConvenientService
 
                       raise #{not_completed_step_error}.new(step: step, method_name: method_name) unless step.completed?
 
-                      raise #{not_existing_step_result_data_attribute_error}.new(step: step, key: key) unless step.result.data.has_attribute?(key)
+                      raise #{not_existing_step_result_data_attribute_error}.new(step: step, key: key) unless step.result.unsafe_data.has_attribute?(key)
 
-                      step.result.data[key]
+                      step.result.unsafe_data[key]
                     end
                   RUBY
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/concern/instance_methods.rb

@@ -38,6 +38,10 @@ module ConvenientService
                   Utils::Bool.to_bool(organizer)
                 end
 
+                def reassignment?(name)
+                  caller.reassignment?(name)
+                end
+
                 def validate_as_input_for_container!(container)
                   direction.validate_as_input_for_container!(container, method: self)
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/base.rb

@@ -27,6 +27,10 @@ module ConvenientService
                     @object = object
                   end
 
+                  def reassignment?(name)
+                    false
+                  end
+
                   def ==(other)
                     return unless other.instance_of?(self.class)
 

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment/commands/define_method_in_container.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Reassignment < Callers::Base
+                  module Commands
+                    class DefineMethodInContainer < Support::Command
+                      include Support::Delegate
+
+                      attr_reader :method, :container, :index
+
+                      delegate :key, :name, to: :method
+
+                      def initialize(method:, container:, index:)
+                        @method = method
+                        @container = container
+                        @index = index
+                      end
+
+                      ##
+                      # @return [Boolean]
+                      #
+                      def call
+                        ##
+                        # NOTE: `prepend` is thread-safe.
+                        #
+                        container.klass.prepend reassigned_methods
+
+                        return false if Utils::Module.instance_method_defined?(reassigned_methods, method, private: true)
+
+                        <<~RUBY.tap { |code| reassigned_methods.module_eval(code, __FILE__, __LINE__ + 1) }
+                          def #{name}
+                            step =
+                              steps
+                                .select { |step| step.has_reassignment?(__method__) }
+                                .select(&:completed?)
+                                .last
+
+                            return super unless step
+
+                            key = step.reassignment(__method__).key.to_sym
+
+                            step.result.unsafe_data[key]
+                          end
+                        RUBY
+
+                        true
+                      end
+
+                      private
+
+                      ##
+                      # @return [Module]
+                      #
+                      def reassigned_methods
+                        @reassigned_methods ||= Utils::Module.fetch_own_const(container.klass, :ReassignedMethods) { ::Module.new }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment/commands.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "commands/define_method_in_container"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "reassignment/commands"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Reassignment < Callers::Base
+                  def reassignment?(name)
+                    ##
+                    # TODO: A better name for `object`. Wrapped object, `target`?
+                    #
+                    object.to_sym == name.to_sym
+                  end
+
+                  ##
+                  # TODO: Separate `in` and `out` methods?
+                  #
+                  def calculate_value(method)
+                    raise Errors::CallerCanNotCalculateReassignment.new(method: method)
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    raise Errors::InputMethodReassignment.new(method: method, container: container)
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    ##
+                    # TODO: Raise when container has two reassignments with same name.
+                    #
+                    true
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    Commands::DefineMethodInContainer.call(method: method, container: container, index: index)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers.rb

@@ -4,4 +4,5 @@ require_relative "callers/base"
 require_relative "callers/alias"
 require_relative "callers/proc"
 require_relative "callers/raw"
+require_relative "callers/reassignment"
 require_relative "callers/usual"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/values/reassignment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Values
+                ##
+                # TODO: Specs.
+                #
+                class Reassignment
+                  include Support::Delegate
+
+                  attr_reader :value
+
+                  delegate :to_s, :to_sym, to: :value
+
+                  ##
+                  # @param value [String, Symbol] Method name to reassign.
+                  #
+                  def initialize(value)
+                    @value = value
+                  end
+
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    return false if value != other.value
+
+                    true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/values.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "values/reassignment"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities.rb

@@ -4,3 +4,4 @@ require_relative "entities/directions"
 require_relative "entities/callers"
 require_relative "entities/key"
 require_relative "entities/name"
+require_relative "entities/values"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/errors.rb

@@ -87,6 +87,28 @@ module ConvenientService
                 end
               end
 
+              class CallerCanNotCalculateReassignment < ::ConvenientService::Error
+                def initialize(method:)
+                  message = <<~TEXT
+                    Method caller failed to calculate reassignment for `#{method.name}`.
+
+                    Method callers can calculate only `in` methods, while reassignments are always `out` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class InputMethodReassignment < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Reassignments are not allowed for `in` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
               class MethodIsNotInputMethod < ConvenientService::Error
                 def initialize(method:, container:)
                   message = <<~TEXT

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

@@ -18,6 +18,12 @@ module ConvenientService
                   :not_success?,
                   :not_failure?,
                   :not_error?,
+                  :data,
+                  :message,
+                  :code,
+                  :unsafe_data,
+                  :unsafe_message,
+                  :unsafe_code,
                   to: :result
 
                 delegate \
@@ -50,10 +56,18 @@ module ConvenientService
                   Utils::Bool.to_bool(organizer)
                 end
 
+                def has_reassignment?(name)
+                  outputs.any? { |output| output.reassignment?(name) }
+                end
+
                 def completed?
                   Utils::Bool.to_bool(@completed)
                 end
 
+                def reassignment(name)
+                  outputs.find { |output| output.reassignment?(name) }
+                end
+
                 def params
                   @params ||= resolve_params
                 end
@@ -66,6 +80,10 @@ module ConvenientService
                   @input_values ||= calculate_input_values
                 end
 
+                def original_result
+                  @original_result ||= calculate_original_result
+                end
+
                 def result
                   @result ||= calculate_result
                 end
@@ -80,6 +98,13 @@ module ConvenientService
                   service.klass.to_s
                 end
 
+                ##
+                # @return [Class]
+                #
+                def service_class
+                  service.klass
+                end
+
                 def validate!
                   inputs.each { |input| input.validate_as_input_for_container!(container) }
 
@@ -106,6 +131,10 @@ module ConvenientService
 
                 attr_reader :args, :kwargs
 
+                ##
+                # @internal
+                #   TODO: Commands instead of private methods.
+                #
                 def calculate_input_values
                   assert_has_organizer!
 
@@ -113,14 +142,21 @@ module ConvenientService
                 end
 
                 ##
-                # IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
+                # @internal
+                #   IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
                 #
-                def calculate_result
+                def calculate_original_result
                   assert_has_organizer!
 
+                  result = service.result(**input_values)
+
                   mark_as_completed!
 
-                  service.result(**input_values)
+                  result
+                end
+
+                def calculate_result
+                  original_result.copy(overrides: {kwargs: {step: self, service: organizer}})
                 end
 
                 def resolve_params

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Plugins
+              module CanHaveParentResult
+                class Middleware < Core::MethodChainMiddleware
+                  def next(...)
+                    chain.next(...).copy(overrides: {kwargs: {parent: entity.original_result}})
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/plugins/can_have_parent_result.rb

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

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/plugins.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require_relative "plugins/can_have_parent_result"
 require_relative "plugins/has_inspect"

data/lib/convenient_service/service/plugins/has_result_steps/entities/step_collection.rb

@@ -36,6 +36,19 @@ module ConvenientService
               steps.each(&block)
             end
 
+            ##
+            # Returns step by index.
+            #
+            # @param index [Integer]
+            # @return [ConvenientService::Service::Plugins::HasResultSteps::Entities::Step]
+            #
+            # @note Works in a similar way as `Array#[]`.
+            # @see https://ruby-doc.org/core-2.7.0/Array.html#method-i-5B-5D
+            #
+            def [](index)
+              steps[index]
+            end
+
             def <<(step)
               steps << step.copy(overrides: {kwargs: {index: next_available_index}})
             end