Module: Trailblazer::Activity::Railway::DSL

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

Defined Under Namespace

Modules: Fail, Pass

Constant Summary collapse

Linear = 
Activity::DSL::Linear
FAILURE_OUTPUT = 
{failure: Activity::Output(Activity::Left, :failure)}
FAILURE_CONNECTOR = 
{Linear::Normalizer::OutputTuples.Output(:failure) => Linear::Strategy.Track(:failure)}
PASS_CONNECTOR = 
{Linear::Normalizer::OutputTuples.Output(:failure) => Linear::Strategy.Track(:success)}
FAIL_CONNECTOR = 
{Linear::Normalizer::OutputTuples.Output(:success) => Linear::Strategy.Track(:failure)}
Normalizers = 
Linear::Normalizer::Normalizers.new(
  step:  Railway::DSL.Normalizer(),
  fail:  Railway::DSL::Fail.Normalizer(),
  pass:  Railway::DSL::Pass.Normalizer(),
  terminus: Linear::Normalizer::Terminus.Normalizer(),
)

Class Method Summary collapse

Class Method Details

.add_failure_connector(ctx, outputs:, non_symbol_options:, failure_connector: FAILURE_CONNECTOR) ⇒ Object 



90
91
92
93
94
95
 
# File 'lib/trailblazer/activity/railway.rb', line 90

def add_failure_connector(ctx, outputs:, non_symbol_options:, failure_connector: FAILURE_CONNECTOR, **)
  return unless outputs[:failure] # do not add the default failure connection when we don't have
                                  # a corresponding output.

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

.add_failure_output(ctx, outputs:) ⇒ Object

Add :failure output to :outputs. This is only called for non-Subprocess steps.



86
87
88
 
# File 'lib/trailblazer/activity/railway.rb', line 86

def add_failure_output(ctx, outputs:, **)
  ctx[:outputs] = FAILURE_OUTPUT.merge(outputs)
end

.Normalizer(prepend_to_default_outputs: []) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/trailblazer/activity/railway.rb', line 9

def Normalizer(prepend_to_default_outputs: [])
  railway_output_steps = {
    "railway.outputs" => Linear::Normalizer.Task(method(:add_failure_output)),
  }

  # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
  step_normalizer = Path::DSL.Normalizer(
    prepend_to_default_outputs: [railway_output_steps, *prepend_to_default_outputs]
  )

  Linear::Normalizer.prepend_to(
    step_normalizer,
    Path::DSL::PREPEND_TO,
    {
      "railway.step.add_failure_connector" => Linear::Normalizer.Task(method(:add_failure_connector)),
    },
  )
end

.options_for_sequence_build(failure_end: Activity::End.new(semantic: :failure), **options) ⇒ Object 



104
105
106
107
108
109
110
 
# File 'lib/trailblazer/activity/railway.rb', line 104

def options_for_sequence_build(failure_end: Activity::End.new(semantic: :failure), **options)
  failure_terminus_options = [failure_end, magnetic_to: :failure, id: "End.failure", normalizers: Normalizers]

  path_options, path_termini = Path::DSL.options_for_sequence_build(**options)

  return path_options, path_termini + [failure_terminus_options]
end