Module: Trailblazer::Activity::FastTrack::DSL

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

Defined Under Namespace

Modules: Fail, Pass

Constant Summary collapse

Linear = 
Activity::DSL::Linear
PREPEND_TO =

The connector logic needs to be run before Railway’s connector logic:

"activity.path_helper.path_to_track"
RECORD_OPTIONS =

inherit: true

[:pass_fast, :fail_fast, :fast_track]
PASS_FAST_OUTPUT = 
{pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast)}
FAIL_FAST_OUTPUT = 
{fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast)}
Normalizers =

Normalizer pipelines taking care of processing your DSL options.

Linear::Normalizer::Normalizers.new(
  step: FastTrack::DSL.Normalizer(),
  fail: FastTrack::DSL::Fail.Normalizer(),
  pass: FastTrack::DSL::Pass.Normalizer(),
  terminus: Linear::Normalizer::Terminus.Normalizer(),
)

Class Method Summary collapse

Class Method Details

.add_fail_fast_output(ctx, outputs:, fail_fast: nil) ⇒ Object 



95
96
97
98
99
 
# File 'lib/trailblazer/activity/fast_track.rb', line 95

def add_fail_fast_output(ctx, outputs:, fail_fast: nil, **)
  return unless fail_fast

  ctx[:outputs] = FAIL_FAST_OUTPUT.merge(outputs)
end

.add_fast_track_connectors(ctx, fast_track: nil) ⇒ Object 



110
111
112
113
 
# File 'lib/trailblazer/activity/fast_track.rb', line 110

def add_fast_track_connectors(ctx, fast_track: nil, **)
  ctx = merge_connections_for!(ctx, :fast_track, :pass_fast, :pass_fast, **ctx)
  ctx = merge_connections_for!(ctx, :fast_track, :fail_fast, :fail_fast, **ctx)
end

.add_fast_track_outputs(ctx, outputs:, fast_track: nil) ⇒ Object 



101
102
103
104
105
 
# File 'lib/trailblazer/activity/fast_track.rb', line 101

def add_fast_track_outputs(ctx, outputs:, fast_track: nil, **)
  return unless fast_track

  ctx[:outputs] = FAIL_FAST_OUTPUT.merge(PASS_FAST_OUTPUT).merge(outputs)
end

.add_pass_fast_output(ctx, outputs:, pass_fast: nil) ⇒ Object 



89
90
91
92
93
 
# File 'lib/trailblazer/activity/fast_track.rb', line 89

def add_pass_fast_output(ctx, outputs:, pass_fast: nil, **)
  return unless pass_fast

  ctx[:outputs] = PASS_FAST_OUTPUT.merge(outputs)
end

.fail_fast_option(ctx, outputs:) ⇒ Object 



127
128
129
130
131
132
133
 
# File 'lib/trailblazer/activity/fast_track.rb', line 127

def fail_fast_option(ctx, outputs:, **)
  ctx = merge_connections_for!(ctx, :fail_fast, :failure, **ctx)

  # DISCUSS: instead of checking outputs here, we could introduce something like Output(non_strict: true)
  ctx = merge_connections_for!(ctx, :fail_fast, :fail_fast, :fail_fast, **ctx) if outputs[:fail_fast]
  ctx
end

.fail_fast_option_for_fail(ctx) ⇒ Object 



135
136
137
138
 
# File 'lib/trailblazer/activity/fast_track.rb', line 135

def fail_fast_option_for_fail(ctx, **)
  ctx = merge_connections_for!(ctx, :fail_fast, :failure, **ctx)
  ctx = merge_connections_for!(ctx, :fail_fast, :success, **ctx)
end

.merge_connections_for!(ctx, option_name, semantic, magnetic_to = option_name, non_symbol_options:) ⇒ Object 



140
141
142
143
144
145
146
147
 
# File 'lib/trailblazer/activity/fast_track.rb', line 140

def merge_connections_for!(ctx, option_name, semantic, magnetic_to=option_name, non_symbol_options:, **)
  return ctx unless ctx[option_name]

  connector = {Linear::Normalizer::OutputTuples.Output(semantic) => Linear::Strategy.Track(magnetic_to)}

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

.Normalizer(prepend_to_default_outputs: [], base_normalizer_builder: Railway::DSL.method(:Normalizer)) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/trailblazer/activity/fast_track.rb', line 16

def Normalizer(prepend_to_default_outputs: [], base_normalizer_builder: Railway::DSL.method(:Normalizer))
  fast_track_output_steps = {
    "fast_track.pass_fast_output"     => Linear::Normalizer.Task(method(:add_pass_fast_output)),
    "fast_track.fail_fast_output"     => Linear::Normalizer.Task(method(:add_fail_fast_output)),
    "fast_track.fast_track_outputs"   => Linear::Normalizer.Task(method(:add_fast_track_outputs)),
  }

  # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
  step_normalizer = base_normalizer_builder.call( # E.g Railway::DSL.NormalizerForPass.
    prepend_to_default_outputs: [fast_track_output_steps, *prepend_to_default_outputs]
  )

  _normalizer = Linear::Normalizer.prepend_to(
    step_normalizer,
    PREPEND_TO,
    {
      "fast_track.record_options"     => Linear::Normalizer.Task(method(:record_options)),
      "fast_track.pass_fast_option"   => Linear::Normalizer.Task(method(:pass_fast_option)),
      "fast_track.fail_fast_option"   => Linear::Normalizer.Task(method(:fail_fast_option)),
      "fast_track.fast_track_option"  => Linear::Normalizer.Task(method(:add_fast_track_connectors)),
    }
  )
end

.options_for_sequence_build(fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **options) ⇒ Object 



157
158
159
160
161
162
163
164
 
# File 'lib/trailblazer/activity/fast_track.rb', line 157

def options_for_sequence_build(fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **options)
  fail_fast_terminus_options = [fail_fast_end, magnetic_to: :fail_fast, id: "End.fail_fast", normalizers: Normalizers]
  past_fast_terminus_options = [pass_fast_end, magnetic_to: :pass_fast, id: "End.pass_fast", normalizers: Normalizers]

  railway_options, railway_termini = Railway::DSL.options_for_sequence_build(**options)

  return railway_options, railway_termini + [fail_fast_terminus_options, past_fast_terminus_options]
end

.pass_fast_option(ctx, outputs:) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/trailblazer/activity/fast_track.rb', line 115

def pass_fast_option(ctx, outputs:, **)
  ctx = merge_connections_for!(ctx, :pass_fast, :success, **ctx)

  ctx = merge_connections_for!(ctx, :pass_fast, :pass_fast, :pass_fast, **ctx) if outputs[:pass_fast]
  ctx
end

.pass_fast_option_for_pass(ctx) ⇒ Object 



122
123
124
125
 
# File 'lib/trailblazer/activity/fast_track.rb', line 122

def pass_fast_option_for_pass(ctx, **)
  ctx = merge_connections_for!(ctx, :pass_fast, :failure, **ctx)
  ctx = merge_connections_for!(ctx, :pass_fast, :success, **ctx)
end

.record_options(ctx, non_symbol_options:) ⇒ Object

If true (or :pass_fast or :fail_fast), record it using Normalizer::Inherit mechanics.



76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/trailblazer/activity/fast_track.rb', line 76

def record_options(ctx, non_symbol_options:, **)
  recorded_options =
    RECORD_OPTIONS.collect { |option| ctx.key?(option) ? [option, ctx[option]] : nil }
      .compact
      .to_h

  ctx.merge!(
    non_symbol_options: non_symbol_options.merge(
      Linear::Normalizer::Inherit.Record(recorded_options, type: :fast_track, non_symbol_options: false)
    )
  )
end