feat(can_have_connected_steps): introduce middleware

lib/convenient_service/service/plugins/can_have_connected_steps.rb

@@ -3,3 +3,4 @@
 require_relative "can_have_connected_steps/concern"
 require_relative "can_have_connected_steps/entities"
 require_relative "can_have_connected_steps/exceptions"
+require_relative "can_have_connected_steps/middleware"

lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/scalar.rb

@@ -77,10 +77,10 @@ def each_step(&block)
               #   IMPORTANT: `each_evaluated_step` calls `result` to be able to use the same RSpec spy for both `each_evaluated_step` and `result?`.
               #
               def each_evaluated_step(&block)
-                yield(step)
-
                 result
 
+                yield(step)
+
                 self
               end
 

lib/convenient_service/service/plugins/can_have_connected_steps/entities/step_collection.rb

@@ -81,7 +81,9 @@ def create(*args, **kwargs)
             # @return [ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::StepCollection]
             #
             def with_organizer(organizer)
-              copy(overrides: {kwargs: {expression: expression.with_organizer(organizer), steps: steps.map { |step| step.with_organizer(organizer) }}})
+              expression_with_organizer = expression.with_organizer(organizer)
+
+              copy(overrides: {kwargs: {expression: expression_with_organizer, steps: expression_with_organizer.steps}})
             end
 
             ##

lib/convenient_service/service/plugins/can_have_connected_steps/middleware.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveConnectedSteps
+        class Middleware < MethodChainMiddleware
+          intended_for :result, entity: :service
+
+          ##
+          # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+          #
+          def next(...)
+            return chain.next(...) if entity.steps.none?
+
+            entity.steps.each_evaluated_step do |step|
+              step.save_outputs_in_organizer!
+
+              step.trigger_callback
+
+              step.mark_as_completed!
+            end
+
+            entity.steps.result
+          end
+        end
+      end
+    end
+  end
+end

spec/lib/convenient_service/service/plugins/can_have_connected_steps/entities/expressions/scalar_spec.rb

@@ -6,6 +6,8 @@
 
 # rubocop:disable RSpec/NestedGroups, RSpec/MultipleMemoizedHelpers
 RSpec.describe ConvenientService::Service::Plugins::CanHaveConnectedSteps::Entities::Expressions::Scalar do
+  include ConvenientService::RSpec::Helpers::IgnoringException
+
   include ConvenientService::RSpec::Matchers::DelegateTo
 
   let(:expression) { described_class.new(step) }
@@ -129,11 +131,17 @@ def foo
       let(:block) { proc { |step| step.index } }
 
       specify do
-        expect { |block| expression.each_evaluated_step(&block) }.to yield_with_args(step)
+        expect { expression.each_evaluated_step(&block) }
+          .to delegate_to(expression, :result)
+          .without_arguments
       end
 
       specify do
-        expect { expression.each_evaluated_step(&block) }
+        expect { |block| expression.each_evaluated_step(&block) }.to yield_with_args(step)
+      end
+
+      it "calls `result` before `yield`" do
+        expect { ignoring_exception(ArgumentError) { expression.each_evaluated_step { raise ArgumentError } } }
           .to delegate_to(expression, :result)
           .without_arguments
       end

spec/lib/convenient_service/service/plugins/can_have_connected_steps/entities/step_collection_spec.rb

@@ -146,11 +146,12 @@
 
     describe "#with_organizer" do
       let(:step_collection) { described_class.new(container: container, expression: expression, steps: steps) }
+      let(:expression_with_organizer) { expression.with_organizer(organizer) }
 
       specify do
         expect { step_collection.with_organizer(organizer) }
           .to delegate_to(step_collection, :copy)
-          .with_arguments(overrides: {kwargs: {expression: expression.with_organizer(organizer), steps: steps.map { |step| step.with_organizer(organizer) }}})
+          .with_arguments(overrides: {kwargs: {expression: expression_with_organizer, steps: expression_with_organizer.steps}})
           .and_return_its_value
       end
     end