Module: Trailblazer::Activity::DSL::Linear::Strategy::DSL

Defined in:
lib/trailblazer/activity/dsl/linear/strategy.rb

Overview

FIXME: do we want class << self?!

Class Method Summary collapse

Class Method Details

.append_terminus(sequence, task, normalizers:, **options) ⇒ Object 



162
163
164
165
 
# File 'lib/trailblazer/activity/dsl/linear/strategy.rb', line 162

def append_terminus(sequence, task, normalizers:, **options)
  # DISCUSS: why are we requiring {:normalizers} here? only for invoking Normalizer.terminus
  _sequence = Linear::Sequence::Builder.update_sequence_for(:terminus, task, options, normalizers: normalizers, sequence: sequence, normalizer_options: {})
end

.Build(strategy, **options, &block) ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/trailblazer/activity/dsl/linear/strategy.rb', line 126

def Build(strategy, **options, &block)
  Class.new(strategy) do
    compile_strategy!(strategy::DSL, normalizers: @state.get(:normalizers), **options)

    class_exec(&block) if block
  end
end

.build_circuit_task_for_step(user_step) ⇒ Object

Wraps user_step into a circuit-interface compatible callable, a.k.a. “task”.



168
169
170
 
# File 'lib/trailblazer/activity/dsl/linear/strategy.rb', line 168

def build_circuit_task_for_step(user_step)
  Activity::Circuit::TaskAdapter.for_step(user_step, option: true)
end

.OptionsForSequenceBuilder(strategy_dsl, termini: nil, **user_options) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/trailblazer/activity/dsl/linear/strategy.rb', line 134

def OptionsForSequenceBuilder(strategy_dsl, termini: nil, **user_options)
  # DISCUSS: instead of calling a separate {initial_sequence} method we could make DSL strategies
  # use the actual DSL to build up the initial_sequence, somewhere outside? Maybe using {:adds}?
  strategy_options, strategy_termini = strategy_dsl.options_for_sequence_build(**user_options) # call Path.options_for_sequence_builder

  # DISCUSS: passing on Normalizers here is a service, not sure I like it.
  initial_sequence = process_termini(strategy_options[:sequence], termini || strategy_termini, normalizers: strategy_dsl::Normalizers)

  {
    step_interface_builder: method(:build_circuit_task_for_step),
    adds:                   [], # DISCUSS: needed?
    **user_options,
    **strategy_options, # this might (and should!) override :track_name etc.
    sequence:               initial_sequence,
  }
  # no {:termini} left in options
end

.process_termini(sequence, termini, **options_for_append_terminus) ⇒ Object

If no :termini were provided by the Strategy user, we use the default strategy_termini.



154
155
156
157
158
159
160
 
# File 'lib/trailblazer/activity/dsl/linear/strategy.rb', line 154

def process_termini(sequence, termini, **options_for_append_terminus)
  termini.each do |task, terminus_options|
    sequence = append_terminus(sequence, task, **options_for_append_terminus, **terminus_options)
  end

  sequence
end

.start_sequence(wirings: []) ⇒ Object 



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

def start_sequence(wirings: [])
  start_default = Activity::Start.new(semantic: :default)
  start_event   = Linear::Sequence.create_row(task: start_default, id: "Start.default", magnetic_to: nil, wirings: wirings)
  _sequence     = Linear::Sequence[start_event]
end