trailblazer-macro 2.1.11 → 2.1.13

data/lib/trailblazer/macro/wrap.rb

@@ -1,81 +1,88 @@
-require 'securerandom'
-
 module Trailblazer
   module Macro
-    def self.Wrap(user_wrap, id: "Wrap/#{SecureRandom.hex(4)}", &block)
-      activity = Class.new(Activity::FastTrack, &block) # This is currently coupled to {dsl-linear}.
-
-      outputs  = activity.to_h[:outputs]
-      outputs  = Hash[outputs.collect { |output| [output.semantic, output] }] # TODO: make that a helper somewhere.
-
-      wrapped  = Wrap::Wrapped.new(activity, user_wrap, outputs)
+    # TODO: {user_wrap}: rename to {wrap_handler}.
+    def self.Wrap(user_wrap, id: Macro.id_for(user_wrap, macro: :Wrap), &block)
+      user_wrap = Wrap.deprecate_positional_wrap_signature(user_wrap)
+
+      block_activity, outputs = Macro.block_activity_for(nil, &block)
+
+      outputs   = Hash[outputs.collect { |output| [output.semantic, output] }] # FIXME: redundant to Subprocess().
+
+      # Since in the user block, you can return Railway.pass! etc, we need to map
+      # those to the actual wrapped block_activity's end.
+      signal_to_output = {
+        Activity::Right               => outputs[:success].signal,
+        Activity::Left                => outputs[:failure].signal,
+        Activity::FastTrack::PassFast => outputs[:pass_fast].signal,
+        Activity::FastTrack::FailFast => outputs[:fail_fast].signal,
+        true               => outputs[:success].signal,
+        false              => outputs[:failure].signal,
+        nil                => outputs[:failure].signal,
+      }
+
+      state = Declarative::State(
+        # this is important, so we subclass the actually wrapped activity when {Wrap} is subclassed.
+        block_activity:   [block_activity, {copy: Trailblazer::Declarative::State.method(:subclass)}],
+        user_wrap:        [user_wrap, {}], # DISCUSS: we could even allow the wrap_handler to be patchable.
+        signal_to_output: [signal_to_output, {}],
+      )
+
+      task = Class.new(Wrap) do
+        extend Macro::Strategy::State # now, the Wrap subclass can inherit its state and copy the {block_activity}.
+        initialize!(state)
+      end
+      # DISCUSS: unfortunately, Ruby doesn't allow to set this during {Class.new}.
 
-      {task: wrapped, id: id, outputs: outputs}
+      {
+        task:     task,
+        id:       id,
+        outputs:  outputs,
+      }
     end
 
-    module Wrap
+    # 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
       # behaves like an operation so it plays with Nested and simply calls the operation in the user-provided block.
-      class Wrapped
-        private def deprecate_positional_wrap_signature(user_wrap)
-          parameters = user_wrap.is_a?(Module) ? user_wrap.method(:call).parameters : user_wrap.parameters
+      # class Wrapped
+      # @private
+      def self.deprecate_positional_wrap_signature(user_wrap)
+        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"
+        return user_wrap if parameters[0] == [:req] # means ((ctx, flow_options), *, &block), "new style"
 
-          ->((ctx, flow_options), **circuit_options, &block) do
-            warn "[Trailblazer] Wrap handlers have a new signature: ((ctx), *, &block)"
-            user_wrap.(ctx, &block)
-          end
+        ->((ctx, flow_options), **circuit_options, &block) do
+          warn "[Trailblazer] Wrap handlers have a new signature: ((ctx), *, &block) XXX"
+          user_wrap.(ctx, &block)
         end
+      end
 
-        def initialize(operation, user_wrap, outputs)
-          user_wrap = deprecate_positional_wrap_signature(user_wrap)
-
-          @operation  = operation
-          @user_wrap  = user_wrap
-
-          # Since in the user block, you can return Railway.pass! etc, we need to map
-          # those to the actual wrapped operation's end.
-          @signal_to_output = {
-            Operation::Railway.pass!      => outputs[:success].signal,
-            Operation::Railway.fail!      => outputs[:failure].signal,
-            Operation::Railway.pass_fast! => outputs[:pass_fast].signal,
-            Operation::Railway.fail_fast! => outputs[:fail_fast].signal,
-            true               => outputs[:success].signal,
-            false              => outputs[:failure].signal,
-            nil                => outputs[:failure].signal,
-          }
+      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)
+        }
+
+        # 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)
+
+        # {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
+        else                     # 2. {task interface return}, only a signal (or true/false)
+          # TODO: deprecate this?
+          signal = returned
         end
 
-        def call((ctx, flow_options), **circuit_options)
-          block_calling_wrapped = -> {
-            call_wrapped_activity([ctx, flow_options], **circuit_options)
-          }
+        # If there's no mapping, use the original {signal} .
+        # This usually means signal is a terminus or a custom signal.
+        signal = @state.get(:signal_to_output).fetch(signal, signal)
 
-          # call the user's Wrap {} block in the operation.
-          # This will invoke block_calling_wrapped above if the user block yields.
-          returned = @user_wrap.([ctx, flow_options], **circuit_options, &block_calling_wrapped)
-
-          # {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
-          else                     # 2. {task interface return}, only a signal (or true/false)
-            # TODO: deprecate this?
-            signal = returned
-          end
-
-          # Use the original {signal} if there's no mapping.
-          # This usually means signal is an End instance or a custom signal.
-          signal = @signal_to_output.fetch(signal, signal)
-
-          return signal, [ctx, flow_options]
-        end
-
-        def call_wrapped_activity((ctx, flow_options), **circuit_options)
-          @operation.to_h[:activity].([ctx, flow_options], **circuit_options) # :exec_context is this instance.
-        end
+        return signal, [ctx, flow_options]
       end
     end # Wrap
   end

data/lib/trailblazer/macro.rb

@@ -2,6 +2,7 @@ require "forwardable"
 require "trailblazer/activity/dsl/linear"
 require "trailblazer/operation" # TODO: remove this dependency
 
+require "trailblazer/macro/strategy"
 require "trailblazer/macro/model"
 require "trailblazer/macro/policy"
 require "trailblazer/macro/guard"
@@ -9,10 +10,60 @@ require "trailblazer/macro/pundit"
 require "trailblazer/macro/nested"
 require "trailblazer/macro/rescue"
 require "trailblazer/macro/wrap"
+require "trailblazer/macro/each"
 
 module Trailblazer
   module Macro
-  end
+      # TaskAdapter::AssignVariable
+        # Run {user_proc} with "step interface" and assign its return value to ctx[@variable_name].
+        # @private
+        # This is experimental.
+    class AssignVariable
+        # name of the ctx variable we want to assign the return_value of {user_proc} to.
+      def initialize(return_value_step, variable_name:)
+        @return_value_step  = return_value_step
+        @variable_name      = variable_name
+      end
+
+      def call((ctx, flow_options), **circuit_options)
+        return_value, ctx = @return_value_step.([ctx, flow_options], **circuit_options)
+
+        ctx[@variable_name] = return_value
+
+        return return_value, ctx
+      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)
+
+      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.
+    end
+
+    def self.block_activity_for(block_activity, &block)
+      return block_activity, block_activity.to_h[:outputs] unless block_given?
+
+      block_activity = Class.new(Activity::FastTrack, &block) # TODO: use Wrap() logic!
+      block_activity.extend Each::Transitive
+
+      return block_activity, block_activity.to_h[:outputs]
+    end
+
+    def self.id_for(user_proc, macro:, hint: nil)
+      id =
+        if user_proc.is_a?(Class)
+          user_proc.to_s
+        elsif user_proc.instance_of?(Method)
+          "method(:#{user_proc.name})"
+        else
+          hint || rand(4)
+        end
+
+      "#{macro}/#{id}"
+    end
+  end # Macro
 
   # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
   # operations and activities to.
@@ -23,6 +74,6 @@ module Trailblazer
     # Extending the {Linear::Helper} namespace is the canonical way to import
     # macros into Railway, FastTrack, Operation, etc.
     extend Forwardable
-    def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
+    def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue, :Each
   end # Helper
 end