Module: Trailblazer::Activity::TaskWrap

Defined in:
lib/trailblazer/activity/task_wrap.rb,
lib/trailblazer/activity/task_wrap/merge.rb,
lib/trailblazer/activity/task_wrap/trace.rb,
lib/trailblazer/activity/task_wrap/runner.rb,
lib/trailblazer/activity/task_wrap/call_task.rb,
lib/trailblazer/activity/task_wrap/variable_mapping.rb

Overview

|– Start

|-- Trace.capture_args   [optional]
|-- Call (call actual task) id: "task_wrap.call_task"
|-- Trace.capture_return [optional]
|-- Wrap::End

Defined Under Namespace

Modules: DSL, Runner, Trace, VariableMapping Classes: Input, Merge, Output

Class Method Summary collapse

Class Method Details

.call_task(wrap_ctx, original_args, **circuit_options) ⇒ Object

TaskWrap step that calls the actual wrapped task and passes all ‘original_args` to it.

It writes to wrap_ctx, wrap_ctx



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/trailblazer/activity/task_wrap/call_task.rb', line 6

def self.call_task((wrap_ctx, original_args), **circuit_options)
  task  = wrap_ctx[:task]

  # Call the actual task we're wrapping here.
  # puts "~~~~wrap.call: #{task}"
  return_signal, return_args = task.(*original_args)

  # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
  wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )

  return Right, [ wrap_ctx, original_args ]
end

.filter_for(filter) ⇒ Object 



25
26
27
28
29
30
31
 
# File 'lib/trailblazer/activity/task_wrap/variable_mapping.rb', line 25

def self.filter_for(filter)
  if filter.is_a?(::Array) || filter.is_a?(::Hash)
    TaskWrap::DSL.filter_from_dsl(filter)
  else
    filter
  end
end

.initial_activity ⇒ Object

The actual activity that implements the taskWrap.



14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/trailblazer/activity/task_wrap.rb', line 14

def self.initial_activity
  Module.new do
    extend Trailblazer::Activity::Path(
      name:             "taskWrap",
      normalizer_class: Magnetic::DefaultNormalizer,
      plus_poles:       Magnetic::PlusPoles.initial( :success => Magnetic::Builder::Path.default_outputs[:success] ) # DefaultNormalizer doesn't give us default PlusPoles.
    )

    task TaskWrap.method(:call_task), id: "task_wrap.call_task" # ::call_task is defined in task_wrap/call_task.
  end
end

.invoke(activity, args, wrap_runtime: {}, **circuit_options) ⇒ Object

Compute runtime arguments necessary to execute a taskWrap per task of the activity.



27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/trailblazer/activity/task_wrap.rb', line 27

def self.invoke(activity, args, wrap_runtime: {}, **circuit_options)
  circuit_options = circuit_options.merge(
    runner:       TaskWrap::Runner,
    wrap_runtime: wrap_runtime,

    activity: { adds: [], circuit: {} }, # for Runner
  )

  # signal, (ctx, flow), circuit_options =
  Runner.(activity, args, circuit_options)
end

.VariableMapping(input:, output:) ⇒ Object

Returns an Extension instance to be thrown into the ‘step` DSL arguments.



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/trailblazer/activity/task_wrap/variable_mapping.rb', line 34

def self.VariableMapping(input:, output:)
  input  = Input.new(
            Input::Scoped.new(
              Trailblazer::Option::KW( filter_for(input) ) ) )

  output = Output.new(
            Output::Unscoped.new(
              Trailblazer::Option::KW( filter_for(output) ) ) )

  Trailblazer::Activity::DSL::Extension.new(
    Merge.new(
      Module.new do
        extend Path::Plan()

        task input,  id: "task_wrap.input", before: "task_wrap.call_task"
        task output, id: "task_wrap.output", before: "End.success", group: :end
      end
    )
  )
end

.wrap_static_for(task, activity:, default_activity: TaskWrap.initial_activity) ⇒ Object

Retrieve the static wrap config from activity. I do not like this part too much, I’d prefer computing the :wrap_static at compile-time for the entire object graph (including nesteds) and simply pass it through to all Runner calls. TODO: simplify that. See above



57
58
59
60
 
# File 'lib/trailblazer/activity/task_wrap/runner.rb', line 57

def self.wrap_static_for(task, activity:, default_activity: TaskWrap.initial_activity, **)
  wrap_static = activity[:wrap_static] || {}
  wrap_static[task] || default_activity
end