coming up with some combined interface that transports the three usual arguments,

plus a processed "value"
plus handy keyword arguments of the "library ctx". feels better.

Author: apotonick

lib/trailblazer/activity/circuit/step.rb

@@ -135,16 +135,11 @@ def self.Step(filter_with_step_interface, **options)
 
 
       class Step___ < Struct.new(:user_filter, :binary?)
-        def self.invoke_callable_with_step_interface(ctx, flow_options, circuit_options)
-          callable = ctx[:callable]
+        def self.invoke_callable_with_step_interface(ctx, flow_options, circuit_options, callable, **kwargs)
 
-          application_ctx = ctx[:application_ctx]
+          result = callable.(ctx, **ctx.to_h) # This is how any Step should be called!
 
-          _result = callable.(application_ctx, **application_ctx.to_h) # This is how any Step should be called!
-
-          ctx[:result] = _result
-
-          return ctx, flow_options, Trailblazer::Activity::Right
+          return ctx, flow_options, result
         end
 
         class Binary < Struct.new(:step)
@@ -161,12 +156,10 @@ def self.compute_signal(ctx, flow_options, result)
           end
 
 
-          def self.___compute_signal(ctx, flow_options, circuit_options)
-            result = ctx.fetch(:result) # we're a step, {result} is always a "boolean".
-
+          def self.___compute_signal(ctx, flow_options, circuit_options, result, **)
+            # we're a step, {result} is always a "boolean".
             signal = Binary.binary_signal_for(result, Activity::Right, Activity::Left)
 
-ctx[:result] = [ctx, flow_options, signal]
             return ctx, flow_options, signal
           end
 

test/circuit_step_test.rb

@@ -128,38 +128,44 @@ def self.call(ctx, outcome:, **)
     assert_equal CU.strip(CU.inspect(ctx)), %({:params=>{:id=>1}, :action=>:update})
     assert_equal signal, {id: 1, exec_context: self} # the handler returns a Hash as a signal?
 
-    ctx, _ = Trailblazer::Activity::Circuit::Step___::Step___Activity___InstanceMethod.(
-      {
-        application_ctx: self.ctx,
+    ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Processor.(
+      Trailblazer::Activity::Circuit::Step___::Step___Activity___InstanceMethod,
+      self.ctx,
+      {},
+      {exec_context: self},
+      "value",
+      **library_ctx = {
         method_name: :my_handler_with_step_interface,
-      }, {}, {exec_context: self}
+      }
       )
 
-    assert_equal CU.strip(CU.inspect(ctx[:application_ctx]))[0..18], %({:params=>{:id=>1},) # FIXME.
+    assert_equal CU.strip(CU.inspect(ctx)), %({:params=>{:id=>1}, :action=>:update, :captured_params=>\"{:id=>1}\"})
+    assert_equal CU.inspect(signal), %({:id=>1})
 
-    ctx, flow_options, signal = Trailblazer::Activity::Circuit::Step___::Step___Activity___InstanceMethod___Binary.(
-      {
-        application_ctx: {outcome: false, params: {id: 1}},
+    ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Processor.(
+      Trailblazer::Activity::Circuit::Step___::Step___Activity___InstanceMethod___Binary,
+      {outcome: false, params: {id: 1}},
+      {},
+      {exec_context: self},
+      "value",
+      **library_ctx = {
         method_name: :my_binary_step_handler,
-      }, {}, {exec_context: self}
+      }
       )
 
-    signal = ctx[:result][2] # FIXME: hm.
-    ctx = ctx[:application_ctx]
     assert_equal signal, Trailblazer::Activity::Left
-    assert_equal CU.strip(CU.inspect(ctx)), %({:outcome=>false, :params=>{:id=>1}, :my_binary_step_handler=>true})
+    assert_equal CU.inspect(ctx), %({:outcome=>false, :params=>{:id=>1}, :my_binary_step_handler=>true})
 
-    ctx, flow_options, signal = Trailblazer::Activity::Circuit::Step___::Step___Activity___Binary.(
-      {
-        application_ctx: {outcome: false, params: {id: 1}},
-        callable: MyBinaryStepHandler,
-      }, {}, {exec_context: self}
+    ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Processor.(
+      Trailblazer::Activity::Circuit::Step___::Step___Activity___Binary,
+      {outcome: false, params: {id: 1}},
+      {},
+      {exec_context: self},
+      MyBinaryStepHandler,
       )
 
-    signal = ctx[:result][2] # FIXME: hm.
-    ctx = ctx[:application_ctx]
     assert_equal signal, Trailblazer::Activity::Left
-    assert_equal CU.strip(CU.inspect(ctx)), %({:outcome=>false, :params=>{:id=>1}, :my_binary_step_handler=>true}) # FIXME.
+    assert_equal CU.inspect(ctx), %({:outcome=>false, :params=>{:id=>1}, :my_binary_step_handler=>true})
   end
 
   it "Circuit::Step with step interface, no binary, returning a value, only" do