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

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

Defined Under Namespace

Modules: Fail, Pass Classes: State

Constant Summary collapse

Linear = 
Activity::DSL::Linear
Normalizers =

Instance

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

Class Method Summary collapse

Class Method Details

.failure_connections ⇒ Object 



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

def failure_connections
  {failure: [Linear::Search.method(:Forward), :failure]}
end

.failure_outputs ⇒ Object 



88
89
90
 
# File 'lib/trailblazer/activity/railway.rb', line 88

def failure_outputs
  {failure: Activity::Output(Activity::Left, :failure)}
end

.initial_sequence(failure_end:, initial_sequence:, **path_options) ⇒ Object 



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

def initial_sequence(failure_end:, initial_sequence:, **path_options)
  # TODO: this could be an Activity itself but maybe a bit too much for now.
  _seq = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
end

.normalize_path_connections(ctx, connections:) ⇒ Object 



84
85
86
 
# File 'lib/trailblazer/activity/railway.rb', line 84

def normalize_path_connections(ctx, connections:, **)
  ctx[:connections] = failure_connections.merge(connections)
end

.normalize_path_outputs(ctx, outputs:) ⇒ Object

Add :failure output to :outputs. TODO: assert that failure_outputs doesn’t override existing :outputs



78
79
80
81
82
 
# File 'lib/trailblazer/activity/railway.rb', line 78

def normalize_path_outputs(ctx, outputs:, **)
  outputs = failure_outputs.merge(outputs)

  ctx[:outputs] = outputs
end

.normalizer ⇒ Object 



10
11
12
 
# File 'lib/trailblazer/activity/railway.rb', line 10

def normalizer
  step_options(Activity::Path::DSL.normalizer)
end

.normalizer_for_fail ⇒ Object

Change some parts of the “normal” normalizer pipeline. TODO: make this easier, even at this step.



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

def normalizer_for_fail
  pipeline = TaskWrap::Pipeline.prepend(
    normalizer,
    "path.wirings",
    {
      "railway.magnetic_to.fail" => Linear::Normalizer.Task(Fail.method(:merge_magnetic_to)),
    }
  )

  pipeline = TaskWrap::Pipeline.prepend(
    pipeline,
    "path.connections",
    {
      "railway.connections.fail.success_to_failure" => Linear::Normalizer.Task(Fail.method(:connect_success_to_failure)),
    },
    replace: 1 # replace {"path.connections"}
  )
end

.normalizer_for_pass ⇒ Object 



36
37
38
39
40
41
42
 
# File 'lib/trailblazer/activity/railway.rb', line 36

def normalizer_for_pass
  pipeline = TaskWrap::Pipeline.insert_after(
    normalizer,
    "path.connections",
    ["railway.connections.pass.failure_to_success", Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))],
  )
end

.OptionsForState(normalizers: Normalizers, failure_end: Activity::End.new(semantic: :failure), **options) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/trailblazer/activity/railway.rb', line 116

def self.OptionsForState(normalizers: Normalizers, failure_end: Activity::End.new(semantic: :failure), **options)
  options = Path::DSL.OptionsForState(**options).
    merge(normalizers: normalizers, failure_end: failure_end)

  initial_sequence = Railway::DSL.initial_sequence(failure_end: failure_end, **options)

  {
    **options,
    initial_sequence: initial_sequence,
  }
end

.step_options(pipeline) ⇒ Object

Add Trailblazer::Activity::Railway steps to normalizer path.



65
66
67
68
69
70
71
72
73
74
 
# File 'lib/trailblazer/activity/railway.rb', line 65

def step_options(pipeline)
  TaskWrap::Pipeline.prepend(
    pipeline,
    "path.wirings",
    {
      "railway.outputs"     => Linear::Normalizer.Task(method(:normalize_path_outputs)),
      "railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
    },
  )
end