Module: Trailblazer::Activity::DSL::Linear::Normalizer::OutputTuples

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

Overview

Implements Output(:success) => Track(:success) Internals are documented: trailblazer.to/2.1/docs/internals.html#internals-wiring-api-output-tuples

Defined Under Namespace

Modules: Connections, Output Classes: End, Id, Track

Class Method Summary collapse

Class Method Details

.filter_inherited_output_tuples(ctx, outputs:, output_tuples:, inherit: false, inherited_recorded_options: {}) ⇒ Object

Implements :outputs, strict: false return connections from parent step which are supported by current step



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb', line 98

def filter_inherited_output_tuples(ctx, outputs:, output_tuples:, inherit: false, inherited_recorded_options: {}, **)
  return unless inherit === true
  strict_outputs = false # TODO: implement "strict outputs" for inherit! meaning we connect all inherited Output regardless of the new activity's interface
  return if strict_outputs === true

  # Grab the inherited {:custom_output_tuples} so we can throw those out if the new activity doesn't support
  # the respective outputs.
  inherited_output_tuples_record  = inherited_recorded_options[:custom_output_tuples]
  inherited_output_tuples         = inherited_output_tuples_record ? inherited_output_tuples_record.options : {}

  allowed_semantics     = outputs.keys # these outputs are exposed by the inheriting step.
  inherited_semantics   = inherited_output_tuples.collect { |output, _| output.semantic }
  unsupported_semantics = inherited_semantics - allowed_semantics

  filtered_output_tuples = output_tuples.reject { |output, _| unsupported_semantics.include?(output.semantic) }

  ctx.merge!(
    output_tuples: filtered_output_tuples.to_h
  )
end

.normalize_output_tuples(ctx, non_symbol_options:) ⇒ Object 



53
54
55
56
57
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb', line 53

def normalize_output_tuples(ctx, non_symbol_options:, **)
  output_tuples = non_symbol_options.find_all { |k, v| k.is_a?(OutputTuples::Output) }

  ctx.merge!(output_tuples: output_tuples)
end

.Output(semantic, is_generic: true) ⇒ Object

Logic related to => …, called “Wiring API”. TODO: move to different namespace (feature/dsl)



43
44
45
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb', line 43

def Output(semantic, is_generic: true)
  Normalizer::OutputTuples::Output::Semantic.new(semantic, is_generic)
end

.register_additional_outputs(ctx, output_tuples:, outputs:) ⇒ Object

Take all Output(signal, semantic), convert to OutputSemantic and extend :outputs. Since only users use this style, we don’t have to filter.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb', line 74

def register_additional_outputs(ctx, output_tuples:, outputs:, **)
  # We need to preserve the order when replacing Output with OutputSemantic,
  # that's why we recreate {output_tuples} here.
  output_tuples =
    output_tuples.collect do |(output, connector)|
      if output.is_a?(Output::CustomOutput)
        # add custom output to :outputs.
        outputs = outputs.merge(output.semantic => Activity.Output(output.signal, output.semantic))

        # Convert Output to OutputSemantic.
        [Strategy.Output(output.semantic), connector]
      else
        [output, connector]
      end
    end

  ctx.merge!(
    output_tuples: output_tuples,
    outputs:       outputs
  )
end

.remember_custom_output_tuples(ctx, output_tuples:, non_symbol_options:) ⇒ Object

Remember all custom (non-generic) :output_tuples.



60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb', line 60

def remember_custom_output_tuples(ctx, output_tuples:, non_symbol_options:, **)
  # We don't include generic OutputSemantic (from Subprocess(strict: true)) for inheritance, as this is not a user customization.
  custom_output_tuples = output_tuples.reject { |k, v| k.generic? }

  # save Output() tuples under {:custom_output_tuples} for inheritance.
  ctx.merge!(
    non_symbol_options: non_symbol_options.merge(
      Normalizer::Inherit.Record(custom_output_tuples.to_h, type: :custom_output_tuples)
    )
  )
end