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

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

Constant Summary collapse

Normalizers =

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

Linear::State::Normalizer.new(
  step: Linear::Normalizer.activity_normalizer( FastTrack::DSL.normalizer ), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
  fail: Linear::Normalizer.activity_normalizer( FastTrack::DSL.normalizer_for_fail ),
  pass: Linear::Normalizer.activity_normalizer( FastTrack::DSL.normalizer_for_pass ),
)

Class Method Summary collapse

Class Method Details

.fail_fast_option(ctx, flow_options) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
 
# File 'lib/trailblazer/activity/fast_track.rb', line 81

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

  ctx = merge_connections_for(ctx, ctx, :fail_fast, :fail_fast, :fail_fast)
  ctx = merge_outputs_for(ctx,
    fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast),
  )

  return Right, [ctx, flow_options]
end

.fail_fast_option_for_fail(ctx, flow_options) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/trailblazer/activity/fast_track.rb', line 92

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

  return Right, [ctx, flow_options]
end

.fast_track_option(ctx, flow_options) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/trailblazer/activity/fast_track.rb', line 99

def fast_track_option((ctx, flow_options), *)
  return Right, [ctx, flow_options] unless ctx[:fast_track]

  ctx = merge_connections_for(ctx, ctx, :fast_track, :fail_fast, :fail_fast)
  ctx = merge_connections_for(ctx, ctx, :fast_track, :pass_fast, :pass_fast)

  ctx = merge_outputs_for(ctx,
    pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast),
    fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast),
  )

  return Right, [ctx, flow_options]
end

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



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

def initial_sequence(initial_sequence:, fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **_o)
  sequence = initial_sequence

  sequence = Path::DSL.append_end(sequence, task: fail_fast_end, magnetic_to: :fail_fast, id: "End.fail_fast")
  sequence = Path::DSL.append_end(sequence, task: pass_fast_end, magnetic_to: :pass_fast, id: "End.pass_fast")
end

.merge_connections_for(ctx, options, option_name, semantic, magnetic_to = option_name) ⇒ Object 



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

def merge_connections_for(ctx, options, option_name, semantic, magnetic_to=option_name)
  return ctx unless options[option_name]

  connections  = ctx[:connections].merge(semantic => [Linear::Search.method(:Forward), magnetic_to])
  ctx          = ctx.merge(connections: connections)
end

.merge_outputs_for(ctx, outputs) ⇒ Object 



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

def merge_outputs_for(ctx, outputs)
  ctx = ctx.merge(
    outputs: outputs.merge(ctx[:outputs])
  )
end

.normalizer ⇒ Object 



20
21
22
 
# File 'lib/trailblazer/activity/fast_track.rb', line 20

def normalizer
  step_options(Trailblazer::Activity::Railway::DSL.normalizer)
end

.normalizer_for_fail ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/trailblazer/activity/fast_track.rb', line 24

def normalizer_for_fail
  sequence = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_fail)

  Path::DSL.prepend_to_path(
    sequence,

    {
      "fast_track.fail_fast_option_for_fail"  => method(:fail_fast_option_for_fail),
    },
    Linear::Insert.method(:Prepend), "path.wirings"
  )
end

.normalizer_for_pass ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/trailblazer/activity/fast_track.rb', line 37

def normalizer_for_pass
  sequence = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_pass)

  Path::DSL.prepend_to_path(
    sequence,

    {
      "fast_track.pass_fast_option_for_pass"  => method(:pass_fast_option_for_pass),
    },
    Linear::Insert.method(:Prepend), "path.wirings"
  )
end

.OptionsForState(normalizers: Normalizers, **options) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/trailblazer/activity/fast_track.rb', line 144

def self.OptionsForState(normalizers: Normalizers, **options)
  options = Railway::DSL.OptionsForState(options).
      merge(normalizers: normalizers)

  initial_sequence = FastTrack::DSL.initial_sequence(**options)

  {
    **options,
    initial_sequence: initial_sequence,
  }
end

.pass_fast_option(ctx, flow_options) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/trailblazer/activity/fast_track.rb', line 63

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

  ctx = merge_connections_for(ctx, ctx, :pass_fast, :pass_fast, :pass_fast)
  ctx = merge_outputs_for(ctx,
    pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast),
  )

  return Right, [ctx, flow_options]
end

.pass_fast_option_for_pass(ctx, flow_options) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/trailblazer/activity/fast_track.rb', line 74

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

  return Right, [ctx, flow_options]
end

.step_options(sequence) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/trailblazer/activity/fast_track.rb', line 50

def step_options(sequence)
  Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
    sequence,

    {
      "fast_track.pass_fast_option"  => method(:pass_fast_option),
      "fast_track.fail_fast_option"  => method(:fail_fast_option),
      "fast_track.fast_track_option" => method(:fast_track_option),
    },
    Linear::Insert.method(:Prepend), "path.wirings"
  )
end