backup

Author: apotonick

lib/trailblazer/macro.rb

@@ -26,21 +26,20 @@ def initialize(return_value_step, variable_name:)
         @variable_name      = variable_name
       end
 
-      def call((ctx, flow_options), **circuit_options)
-        return_value, ctx = @return_value_step.([ctx, flow_options], **circuit_options)
+      def call(ctx, flow_options, circuit_options)
+        puts "yooo"
+        ctx, flow_options, return_value = @return_value_step.(ctx, flow_options, circuit_options)
 
         ctx[@variable_name] = return_value
 
-        return return_value, ctx
+        return ctx, flow_options, Trailblazer::Activity::Right
       end
     end
 
     def self.task_adapter_for_decider(decider_with_step_interface, variable_name:)
-      return_value_circuit_step = Activity::Circuit.Step(decider_with_step_interface, option: true)
+      return_value_circuit_step = Activity::Circuit.Step(decider_with_step_interface) # FIXME: this should be binary!
 
-      assign_task = AssignVariable.new(return_value_circuit_step, variable_name: variable_name)
-
-      Activity::Circuit::TaskAdapter.new(assign_task) # call {assign_task} with circuit-interface, interpret result.
+      AssignVariable.new(return_value_circuit_step, variable_name: variable_name)
     end
 
     def self.block_activity_for(block_activity, &block)

lib/trailblazer/macro/guard.rb

@@ -6,10 +6,12 @@ def self.Guard(proc, name: :default, &block)
 
     module Guard
       def self.build(callable)
-        option = Trailblazer::Option(callable)
+        option = Trailblazer::Activity::Circuit::Step(callable) # DISCUSS: should we use Option here directly?
 
-        ->((ctx, *), **circuit_args) do
-          Trailblazer::Operation::Result.new(!!option.call(ctx, keyword_arguments: ctx.to_hash, **circuit_args), {})
+        ->(ctx, flow_options, circuit_options) do
+          _, _, result = option.call(ctx, flow_options, circuit_options)
+
+          Trailblazer::Operation::Result.new(!!result, {})
         end
       end
     end

lib/trailblazer/macro/model.rb

@@ -2,7 +2,7 @@ module Trailblazer
   module Macro
 
     def self.Model(model_class = nil, action = :new, find_by_key = :id, id: 'model.build', not_found_terminus: false)
-      task = Activity::Circuit::TaskAdapter.for_step(Model.new)
+      task = Activity::Circuit.Step(Model.new, binary: true)
 
       injections = {
         Activity::Railway.Inject() => [:params], # pass-through {:params} if it's in ctx.
@@ -25,7 +25,7 @@ def call(ctx, params: {}, **)
         builder = Builder.new
         model   = builder.call(ctx, params) or return
 
-        ctx[:model] = model
+        ctx[:model] = model # DISCUSS: what about nil models?
       end
 
       class Builder

lib/trailblazer/macro/model/find.rb

@@ -80,7 +80,7 @@ def self.for_keywords(model_class, find_method:, **options, &block) # FIXME: def
       end
 
       def self.for_query(model_class, query, column_key: :id, params_key: column_key, **, &block) # FIXME: defaulting is redundant with bla_explicit_positional.
-        query_on_model_class = ->(ctx, **kws) { model_class.instance_exec(ctx, **kws, &query) } # FIXME: we can only use procs here. what about methods, classes etc?
+        query_on_model_class = ->(ctx, **kws) { puts kws.inspect; model_class.instance_exec(ctx, **kws, &query) } # FIXME: we can only use procs here. what about methods, classes etc?
 
         finder = Macro.task_adapter_for_decider(query_on_model_class, variable_name: :model) # FIXME: {:model} is hard-coded.
 

lib/trailblazer/macro/policy.rb

@@ -12,17 +12,18 @@ def initialize(name: nil, path: nil)
       # outgoing Task::Binary API.
       #
       # Retrieve the injectable {condition}, execute it and interpret its {Result} object.
-      def call((ctx, flow_options), **circuit_options)
+      def call(ctx, flow_options, circuit_options)
         condition = ctx[@path] # this allows dependency injection.
-        result    = condition.([ctx, flow_options], **circuit_options)
+        result    = condition.(ctx, flow_options, circuit_options)
+        puts "@@@@@ #{result.inspect}"
 
         ctx[:"policy.#{@name}"]        = result[:policy] # assign the policy as a ctx variable.
         ctx[:"result.policy.#{@name}"] = result
 
         # flow control
         signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left
 
-        return signal, [ctx, flow_options]
+        return ctx, flow_options, signal
       end
     end
 

lib/trailblazer/macro/rescue.rb

@@ -2,44 +2,24 @@ module Trailblazer
   module Macro
     NoopHandler = lambda { |*| }
 
-    def self.Rescue(*exceptions, handler: NoopHandler, id: Rescue.random_id, &block)
+    def self.Rescue(*exceptions, handler: NoopHandler, id: Macro.id_for(nil, macro: :Rescue), &block)
       exceptions = [StandardError] unless exceptions.any?
 
-      handler    = Rescue.deprecate_positional_handler_signature(handler)
-      handler    = Trailblazer::Option(handler)
+      handler    = Trailblazer::Activity::Circuit.Step(handler)
 
       # This block is evaluated by {Wrap}.
       rescue_block = ->((ctx, flow_options), **circuit_options, &nested_activity) do
         begin
           nested_activity.call
         rescue *exceptions => exception
           # DISCUSS: should we deprecate this signature and rather apply the Task API here?
-          handler.call(exception, ctx, **circuit_options) # FIXME: when there's an error here, it shows the wrong exception!
+          handler.call(exception, ctx, flow_options, circuit_options) # FIXME: when there's an error here, it shows the wrong exception!
 
-          [Operation::Railway.fail!, [ctx, flow_options]]
+          return ctx, flow_options, Operation::Railway.fail!
         end
       end
 
       Wrap(rescue_block, id: id, &block)
     end
-
-    # TODO: remove me in 2.2.
-    module Rescue
-      def self.deprecate_positional_handler_signature(handler)
-        return handler if handler.is_a?(Symbol) # can't do nothing about this.
-        return handler if handler.method(:call).arity != 2 # means (exception, (ctx, flow_options), *, &block), "new style"
-
-        ->(exception, (ctx, flow_options), **circuit_options, &block) do
-          warn "[Trailblazer] Rescue handlers have a new signature: (exception, *, &block)"
-          handler.(exception, ctx, &block)
-        end
-      end
-
-      # TODO: for legacy reasons, we pass `:id` to {#id_for}. In 2.2, remove the id hint and use
-      # generic {Macro.id_for} behavior.
-      def self.random_id
-        Macro.id_for(nil, macro: :Rescue, id: rand(1000))
-      end
-    end
   end
 end

lib/trailblazer/macro/wrap.rb

@@ -42,11 +42,14 @@ def self.Wrap(user_wrap, id: Macro.id_for(user_wrap, macro: :Wrap), &block)
 
     # Wrap exposes {#inherited} which will also copy the block activity.
     # Currently, this is only used for patching (as it will try to subclass Wrap).
-    class Wrap < Macro::Strategy # TODO: it would be cool to have Activity::Interface and Strategy::Interface
+    class Wrap < Macro::Strategy
       # behaves like an operation so it plays with Nested and simply calls the operation in the user-provided block.
       # class Wrapped
       # @private
       def self.deprecate_positional_wrap_signature(user_wrap)
+        return user_wrap
+        # FIXME: deprecate old array-kwargs based circuit interface.
+
         parameters = user_wrap.is_a?(Proc) || user_wrap.is_a?(Method) ? user_wrap.parameters : user_wrap.method(:call).parameters
 
         return user_wrap if parameters[0] == [:req] # means ((ctx, flow_options), *, &block), "new style"
@@ -57,22 +60,23 @@ def self.deprecate_positional_wrap_signature(user_wrap)
         end
       end
 
-      def self.call((ctx, flow_options), **circuit_options)
+      def self.call(ctx, flow_options, circuit_options)
         # since yield is called without arguments, we need to pull default params from here. Oh ... tricky.
-        block_calling_wrapped = ->(args=[ctx, flow_options], kwargs=circuit_options) {
-          Activity::Circuit::Runner.(block_activity, args, **kwargs)
+
+        block_called_from_user_yield = ->() { # DISCUSS: because we allow users to call {yield}, we don't receive any args here.
+          Activity::Circuit::Runner.(block_activity, ctx, flow_options, circuit_options)
         }
 
         # call the user's Wrap {} block in the operation.
-        # This will invoke block_calling_wrapped above if the user block yields.
-        returned = @state.get(:user_wrap).([ctx, flow_options], **circuit_options, &block_calling_wrapped)
+        # This will invoke block_called_from_user_yield above if the user block yields.
+        returned = @state.get(:user_wrap).(ctx, flow_options, circuit_options, &block_called_from_user_yield)
 
         # {returned} can be
         #   1. {circuit interface return} from the begin block, because the wrapped OP passed
         #   2. {task interface return} because the user block returns "customized" signals, true of fale
 
         if returned.is_a?(Array) # 1. {circuit interface return}, new style.
-          signal, (ctx, flow_options) = returned
+          ctx, flow_options, signal = returned
         else                     # 2. {task interface return}, only a signal (or true/false)
           # TODO: deprecate this?
           signal = returned
@@ -82,7 +86,7 @@ def self.call((ctx, flow_options), **circuit_options)
         # This usually means signal is a terminus or a custom signal.
         signal = @state.get(:signal_to_output).fetch(signal, signal)
 
-        return signal, [ctx, flow_options]
+        return ctx, flow_options, signal
       end
     end # Wrap
   end