introducing a new "Processor interface" that i like much better than any other

attempt. it should work for Step/Task, but also for I/O and for the taskWrap itself.

```
def self.compute_callable(ctx, flow_options, circuit_options, signal, lib_ctx, method_name:, **)
```

the idea is to have an extended signature of the circuit interface, where two positional args
signal and lib_ctx are passed around, the lib_ctx is automatically passed as kwargs. this used to
be the `wrap_ctx` in the original taskWrap version.
you `return ctx, flow_options, signal, lib_ctx`, and signal can be anything.

Author: apotonick

lib/trailblazer/activity/circuit/step.rb

@@ -8,55 +8,43 @@ def self.Task(filter_with_circuit_interface)
       end
 
       class Processor #< Pipeline
-        def self.call(pipeline, ctx, flow_options, circuit_options, value = nil, **kws)
+        def self.call(pipeline, ctx, flow_options, circuit_options, signal = nil, lib_ctx)
           pipeline.to_a.each do |(_id, task)|
             puts "@@@@@ #{task.inspect}"
-            # raise "should we pass around value in kws?"
-            ctx, flow_options, value = task.(ctx, flow_options, circuit_options, value, **kws)
+            ctx, flow_options, signal, lib_ctx = task.(ctx, flow_options, circuit_options, signal, lib_ctx, **lib_ctx)
           end
 
-          return ctx, flow_options, value # FIXME: experimenting here.
+          return ctx, flow_options, signal, lib_ctx # FIXME: experimenting here.
         end
       end
 
       class Task___Activity# < Activity::Railway # TODO: naming.
-      # DISCUSS: make the third argument pass-through?
-
-
         module Generic # DISCUSS: rename back to {Callable}?
           # TODO: this is generic, applies to Task and Step!!!
           class InstanceMethod
             # This is one "step" for the Task/Step adapter, specific to instance methods,
             # and it allows calling the returned callable as if it was a MyHandler.
             # RUNTIME, THIS IS EXECUTED BY THE TASK/STEP instance.
-            def self.compute_callable(ctx, flow_options, circuit_options, value, method_name:, **)
+            def self.compute_callable(ctx, flow_options, circuit_options, signal, lib_ctx, method_name:, **)
               exec_context  = circuit_options.fetch(:exec_context)
               # That was my first idea, but it doesn't play if devs would use dispatching based on {#method_missing}.
               # callable      = exec_context.method(method_name) # this is the actual change from Option thinking.
 
-              # method_name = ctx.fetch(:method_name)
-
               callable = ->(*args, **kws) { exec_context.send(method_name, *args, **kws) } # this should be generic, so we can use it with Task and Step interfaces (and ext-ci)
 
   # tHE IDEA here is that the only difference to a raw filter is that we extract the "callable" before we do the rest
   # (invoking with whatever interface, interpreting the result etc)
-              # ctx[:callable] = callable
 
-              return ctx, flow_options, callable
+              return ctx, flow_options, callable, lib_ctx
             end
           end
 
-          def self.invoke_callable(ctx, flow_options, circuit_options, callable, callable_keyword_arguments: {}, **kwargs)
-            # callable = ctx[:callable]
-            # application_ctx = ctx[:application_ctx]
-
+          def self.invoke_callable(ctx, flow_options, circuit_options, callable, lib_ctx, callable_keyword_arguments: {}, **)
             # DISCUSS: we currently need {callable_keyword_arguments} only in one spot (if I remember correctly, that's the Rescue handler and :exception)
 
             ctx, flow_options, signal = callable.(ctx, flow_options, circuit_options, **callable_keyword_arguments) # This is how any Task is invoked!
 
-            # DISCUSS: do we want another return set? Shouldn't that be the Task's responsibility?
-            # ctx[:result] = result
-            return ctx, flow_options, signal
+            return ctx, flow_options, signal, lib_ctx
           end
         end # Generic
 
@@ -80,7 +68,6 @@ def call(ctx, flow_options, circuit_options, **kwargs)
             callable = task_instance_method_wrap.(ctx, flow_options, circuit_options, **kwargs)  #this step is specific to instance methods
 
             callable.(ctx, flow_options, circuit_options, **kwargs) # This is how any Task is invoked!
-            # return
           end
         end
 
@@ -135,11 +122,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, **kwargs)
+        def self.invoke_callable_with_step_interface(ctx, flow_options, circuit_options, callable, lib_ctx, **)
 
           result = callable.(ctx, **ctx.to_h) # This is how any Step should be called!
 
-          return ctx, flow_options, result
+          return ctx, flow_options, result, lib_ctx
         end
 
         class Binary < Struct.new(:step)
@@ -156,11 +143,11 @@ def self.compute_signal(ctx, flow_options, result)
           end
 
 
-          def self.___compute_signal(ctx, flow_options, circuit_options, result, **)
+          def self.___compute_signal(ctx, flow_options, circuit_options, result, lib_ctx, **)
             # we're a step, {result} is always a "boolean".
             signal = Binary.binary_signal_for(result, Activity::Right, Activity::Left)
 
-            return ctx, flow_options, signal
+            return ctx, flow_options, signal, lib_ctx
           end
 
           # Translates the return value of the user step into a valid signal.

test/circuit_step_test.rb

@@ -111,13 +111,13 @@ def self.call(ctx, outcome:, **)
 
     # Let's invoke a Task :instance_method.
     # ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Task___Activity::InstanceMethod.(
-    ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Processor.(
+    ctx, _flow_options, signal, _library_ctx = Trailblazer::Activity::Circuit::Processor.(
       Trailblazer::Activity::Circuit::Task___Activity::InstanceMethod,
       self.ctx,
       {},
       {exec_context: self},
-      "value",
-      **library_ctx = {
+      nil, # "signal"
+      library_ctx = {
         method_name: :my_output_with_circuit_interface
       }
       )
@@ -126,15 +126,17 @@ def self.call(ctx, outcome:, **)
 #       is it worth that?
 
     assert_equal CU.strip(CU.inspect(ctx)), %({:params=>{:id=>1}, :action=>:update})
+    assert_equal _flow_options, {}
     assert_equal signal, {id: 1, exec_context: self} # the handler returns a Hash as a signal?
+    assert_equal _library_ctx, library_ctx
 
-    ctx, _flow_options, signal = Trailblazer::Activity::Circuit::Processor.(
+    ctx, _flow_options, signal, _library_ctx = Trailblazer::Activity::Circuit::Processor.(
       Trailblazer::Activity::Circuit::Step___::Step___Activity___InstanceMethod,
       self.ctx,
       {},
       {exec_context: self},
-      "value",
-      **library_ctx = {
+      nil, # "signal"
+      library_ctx = {
         method_name: :my_handler_with_step_interface,
       }
       )
@@ -162,6 +164,7 @@ def self.call(ctx, outcome:, **)
       {},
       {exec_context: self},
       MyBinaryStepHandler,
+      {} # library_ctx
       )
 
     assert_equal signal, Trailblazer::Activity::Left