Module: Trailblazer::Activity::DSL::Linear::Normalizer::Terminus

Defined in:
lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb

Overview

Normalizer pipeline for the terminus DSL method.

Class Method Summary collapse

Class Method Details

._normalize_task_for_end_event(ctx, task:) ⇒ Object

you cannot override using :semantic



51
52
53
54
55
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 51

def _normalize_task_for_end_event(ctx, task:, **) # you cannot override using {:semantic}
  ctx.merge!(
    semantic: task.to_h[:semantic]
  )
end

._normalize_task_for_symbol(ctx, task:, semantic: task) ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 57

def _normalize_task_for_symbol(ctx, task:, semantic: task, **)
  ctx.merge!(
    task:     Activity.End(semantic),
    semantic: semantic
  )
end

.append_end(ctx, task:, append_to: "End.success", non_symbol_options:) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 71

def append_end(ctx, task:, append_to: "End.success", non_symbol_options:, **)
  terminus_args = {
    sequence_insert:    [Activity::Adds::Insert.method(:Append), append_to],
    stop_event:         true,
    non_symbol_options: non_symbol_options.merge(Strategy.DataVariable() => [:stop_event, :semantic])
  }

  ctx.merge!(
    wirings: [],
    adds:    [],
    **terminus_args
  )
end

.normalize_id(ctx, semantic:, id: nil) ⇒ Object 



34
35
36
37
38
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 34

def normalize_id(ctx, semantic:, id: nil, **)
  ctx.merge!(
    id: id || Strategy.end_id(semantic: semantic)
  )
end

.normalize_magnetic_to(ctx, magnetic_to: nil, semantic:) ⇒ Object 



65
66
67
68
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 65

def normalize_magnetic_to(ctx, magnetic_to: nil, semantic:, **)
  return if magnetic_to
  ctx.merge!(magnetic_to: semantic)
end

.normalize_task(ctx, task:) ⇒ Object

Set :task and :semantic.



42
43
44
45
46
47
48
49
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 42

def normalize_task(ctx, task:, **)
  if task.is_a?(Activity::End) # DISCUSS: do we want this check?
    _ctx = _normalize_task_for_end_event(ctx, **ctx)
  else
    # When used such as {terminus :found}, create the end event automatically.
    _ctx = _normalize_task_for_symbol(ctx, **ctx)
  end
end

.Normalizer ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb', line 10

def Normalizer
  normalizer_steps =
    {
      "activity.normalize_step_interface"       => Normalizer.Task(Normalizer.method(:normalize_step_interface)),      # first
      "activity.merge_library_options"          => Normalizer.Task(Normalizer.method(:merge_library_options)),    # Merge "macro"/user options over library options.
      "activity.normalize_for_macro"            => Normalizer.Task(Normalizer.method(:merge_user_options)),
      "activity.normalize_normalizer_options"   => Normalizer.Task(Normalizer.method(:merge_normalizer_options)),
      "activity.normalize_non_symbol_options"   => Normalizer.Task(Normalizer.method(:normalize_non_symbol_options)),
      "activity.normalize_context"              => Normalizer.method(:normalize_context),
      "terminus.normalize_task"                 => Normalizer.Task(Terminus.method(:normalize_task)),
      "terminus.normalize_id"                   => Normalizer.Task(method(:normalize_id)),
      "terminus.normalize_magnetic_to"          => Normalizer.Task(Terminus.method(:normalize_magnetic_to)),
      "terminus.append_end"                     => Normalizer.Task(Terminus.method(:append_end)),

      "activity.compile_data" => Normalizer.Task(Normalizer.method(:compile_data)), # FIXME: redundant with {Linear::Normalizer}.
      "activity.create_row" => Normalizer.Task(Normalizer.method(:create_row)),
      "activity.create_add" => Normalizer.Task(Normalizer.method(:create_add)),
      "activity.create_adds" => Normalizer.Task(Normalizer.method(:create_adds)),
    }

  TaskWrap::Pipeline.new(normalizer_steps.to_a)
end