Module: Trailblazer::Activity::Path::DSL

Defined in:
lib/trailblazer/activity/path.rb

Overview

Functions that help creating a path-specific sequence.

Constant Summary collapse

Linear = 
Activity::DSL::Linear
PREPEND_TO =

Always prepend all “add connectors” steps of all normalizers to normalize_output_tuples. This assures that the order is

[<default tuples>, <inherited tuples>, <user tuples>]

"output_tuples.normalize_output_tuples"
SUCCESS_OUTPUT = 
{success: Activity::Output(Activity::Right, :success)}
Normalizers =

This is slow and should be done only once at compile-time, These are the normalizers for an Trailblazer::Activity, to be injected into a State.

Linear::Normalizer::Normalizers.new(
  step:     Normalizer(), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
  terminus: Linear::Normalizer::Terminus.Normalizer(),
)

Class Method Summary collapse

Class Method Details

.add_success_connector(ctx, track_name:, non_symbol_options:) ⇒ Object 



41
42
43
44
45
 
# File 'lib/trailblazer/activity/path.rb', line 41

def add_success_connector(ctx, track_name:, non_symbol_options:, **)
  connectors = {Linear::Normalizer::OutputTuples.Output(:success) => Linear::Strategy.Track(track_name)}

  ctx[:non_symbol_options] = connectors.merge(non_symbol_options)
end

.add_success_output(ctx) ⇒ Object 



37
38
39
 
# File 'lib/trailblazer/activity/path.rb', line 37

def add_success_output(ctx, **)
  ctx[:outputs] = SUCCESS_OUTPUT
end

.normalize_magnetic_to(ctx, track_name:) ⇒ Object

TODO: merge with Railway.merge_magnetic_to



47
48
49
 
# File 'lib/trailblazer/activity/path.rb', line 47

def normalize_magnetic_to(ctx, track_name:, **) # TODO: merge with Railway.merge_magnetic_to
  ctx[:magnetic_to] = ctx.key?(:magnetic_to) ? ctx[:magnetic_to] : track_name # FIXME: can we be magnetic_to {nil}?
end

.Normalizer(prepend_to_default_outputs: []) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/trailblazer/activity/path.rb', line 15

def Normalizer(prepend_to_default_outputs: [])
  path_output_steps = {
    "path.outputs" => Linear::Normalizer.Task(method(:add_success_output))
  }

  # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
  dsl_normalizer = Linear::Normalizer.Normalizer(
    prepend_to_default_outputs: [*prepend_to_default_outputs, path_output_steps]
  )

  Linear::Normalizer.prepend_to(
    dsl_normalizer,
    PREPEND_TO,
    {
      "path.step.add_success_connector" => Linear::Normalizer.Task(method(:add_success_connector)),
      "path.magnetic_to"                => Linear::Normalizer.Task(method(:normalize_magnetic_to)),
    }
  )
end

.options_for_sequence_build(track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success") ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/trailblazer/activity/path.rb', line 67

def options_for_sequence_build(track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **)
  initial_sequence = start_sequence(track_name: track_name)

  termini = [
    [end_task, id: end_id, magnetic_to: track_name, append_to: "Start.default"]
  ]

  options = {
    sequence:   initial_sequence,
    track_name: track_name,
    end_id:     end_id,           # needed in Normalizer.normalize_sequence_insert.
  }

  return options, termini
end

.start_sequence(track_name:) ⇒ Object 



63
64
65
 
# File 'lib/trailblazer/activity/path.rb', line 63

def start_sequence(track_name:)
  Linear::Strategy::DSL.start_sequence(wirings: [Linear::Sequence::Search::Forward(SUCCESS_OUTPUT[:success], track_name)])
end