module Trailblazer::Activity::Railway::DSL

Constants

Linear
Normalizers

Public Class Methods

OptionsForState(normalizers: Normalizers, failure_end: Activity::End.new(semantic: :failure), **options) click to toggle source
# File lib/trailblazer/activity/railway.rb, line 137
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

Public Instance Methods

failure_connections() click to toggle source
# File lib/trailblazer/activity/railway.rb, line 112
def failure_connections
  {failure: [Linear::Search.method(:Forward), :failure]}
end
failure_outputs() click to toggle source
# File lib/trailblazer/activity/railway.rb, line 109
def failure_outputs
  {failure: Activity::Output(Activity::Left, :failure)}
end
initial_sequence(failure_end:, initial_sequence:, **path_options) click to toggle source
# File lib/trailblazer/activity/railway.rb, line 116
def initial_sequence(failure_end:, initial_sequence:, **path_options)
  # TODO: this could be an Activity itself but maybe a bit too much for now.
  sequence = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
end
normalize_path_connections((ctx, flow_options), *) click to toggle source
# File lib/trailblazer/activity/railway.rb, line 102
def normalize_path_connections((ctx, flow_options), *)
  connections = failure_connections.merge(ctx[:connections])
  ctx         = ctx.merge(connections: connections)

  return Right, [ctx, flow_options]
end
normalize_path_outputs((ctx, flow_options), *) click to toggle source

Add {:failure} output to {:outputs}. TODO: assert that failure_outputs doesn't override existing {:outputs}

# File lib/trailblazer/activity/railway.rb, line 95
def normalize_path_outputs((ctx, flow_options), *)
  outputs = failure_outputs.merge(ctx[:outputs])
  ctx     = ctx.merge(outputs: outputs)

  return Right, [ctx, flow_options]
end
normalizer() click to toggle source
# File lib/trailblazer/activity/railway.rb, line 10
def normalizer
  step_options(Activity::Path::DSL.normalizer)
end
normalizer_for_fail() click to toggle source

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

# File lib/trailblazer/activity/railway.rb, line 17
        def normalizer_for_fail
          sequence = normalizer

          id = "railway.magnetic_to.fail"
          task = Fail.method(:merge_magnetic_to)

# TODO: use prepend_to_path
          sequence = Linear::DSL.insert_task(sequence,
            task: task,
            magnetic_to: :success, id: id,
            wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
            sequence_insert: [Linear::Insert.method(:Prepend), "path.wirings"])

          id = "railway.connections.fail.success_to_failure"
          task = Fail.method(:connect_success_to_failure)

          sequence = Linear::DSL.insert_task(sequence,
            task: task,
            magnetic_to: :success, id: id,
            wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
            sequence_insert: [Linear::Insert.method(:Replace), "path.connections"])
        end
normalizer_for_pass() click to toggle source
# File lib/trailblazer/activity/railway.rb, line 40
def normalizer_for_pass
  sequence = normalizer

  id = "railway.connections.pass.failure_to_success"
  task = Pass.method(:connect_failure_to_success)

  sequence = Linear::DSL.insert_task(sequence,
    task: task,
    magnetic_to: :success, id: id,
    wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
    sequence_insert: [Linear::Insert.method(:Append), "path.connections"])
end
step_options(sequence) click to toggle source

Add {Railway} steps to normalizer path.

# File lib/trailblazer/activity/railway.rb, line 80
def step_options(sequence)
  Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
    sequence,

    {
      "railway.outputs"     => method(:normalize_path_outputs),
      "railway.connections" => method(:normalize_path_connections),
    },

    Linear::Insert.method(:Prepend), "path.wirings" # override where it's added.
  )
end