class Trailblazer::Activity::Schema::Inter

An {Intermediate} structure defines the structure of the circuit. It usually comes from a DSL or a visual editor.

Constants

Out
TaskRef

Public Class Methods

Out(*args) click to toggle source
# File lib/trailblazer/activity/schema/intermediate.rb, line 10
def self.Out(*args);           Out.new(*args)        end
TaskRef(id, data={}) click to toggle source
# File lib/trailblazer/activity/schema/intermediate.rb, line 9
def self.TaskRef(id, data={}); TaskRef.new(id, data) end
call(intermediate, implementation, config_merge: {}) click to toggle source

Compiles a {Schema} instance from an {intermediate} structure and the {implementation} object references.

Intermediate structure, Implementation, calls extensions, passes {config} # TODO

# File lib/trailblazer/activity/schema/intermediate.rb, line 16
def self.call(intermediate, implementation, config_merge: {})
  config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
  config         = config_default.merge(config_merge)
  config.freeze

  circuit = circuit(intermediate, implementation)
  nodes   = node_attributes(intermediate, implementation)
  outputs = outputs(intermediate.stop_task_ids, nodes)
  config  = config(implementation, config: config)
  Schema.new(circuit, outputs, nodes, config)
end
circuit(intermediate, implementation) click to toggle source

From the intermediate “template” and the actual implementation, compile a {Circuit} instance.

# File lib/trailblazer/activity/schema/intermediate.rb, line 29
def self.circuit(intermediate, implementation)
  end_events = intermediate.stop_task_ids

  wiring = Hash[
    intermediate.wiring.collect do |task_ref, outs|
      task = implementation.fetch(task_ref.id)

      [
        task.circuit_task,
        end_events.include?(task_ref.id) ? {} : connections_for(outs, task.outputs, implementation)
      ]
    end
  ]

  Circuit.new(
    wiring,
    intermediate.stop_task_ids.collect { |id| implementation.fetch(id).circuit_task },
    start_task: intermediate.start_task_ids.collect { |id| implementation.fetch(id).circuit_task }[0]
  )
end
config(implementation, config:) click to toggle source

Invoke each task's extensions (usually coming from the DSL or some macro).

# File lib/trailblazer/activity/schema/intermediate.rb, line 80
def self.config(implementation, config:)
  implementation.each do |id, task|
    task.extensions.each { |ext| config = ext.(config: config, id: id, task: task) } # DISCUSS: ext must return new {Config}.
  end

  config
end
connections_for(outs, task_outputs, implementation) click to toggle source

Compute the connections for {circuit_task}.

# File lib/trailblazer/activity/schema/intermediate.rb, line 51
def self.connections_for(outs, task_outputs, implementation)
  Hash[
    outs.collect { |required_out|
      [
        for_semantic(task_outputs, required_out.semantic).signal,
        implementation.fetch(required_out.target).circuit_task
      ]
    }.compact
  ]
end
node_attributes(intermediate, implementation) click to toggle source
# File lib/trailblazer/activity/schema/intermediate.rb, line 62
def self.node_attributes(intermediate, implementation)
  intermediate.wiring.collect do |task_ref, outputs| # id, Task{circuit_task, outputs}
    task = implementation.fetch(task_ref.id)
    data = task_ref[:data] # TODO: allow adding data from implementation.

    NodeAttributes.new(task_ref.id, task.outputs, task.circuit_task, data)
  end
end
outputs(stop_task_ids, nodes_attributes) click to toggle source

intermediate/implementation independent.

# File lib/trailblazer/activity/schema/intermediate.rb, line 72
def self.outputs(stop_task_ids, nodes_attributes)
  stop_task_ids.collect do |id|
    # Grab the {outputs} of the stop nodes.
    nodes_attributes.find { |node_attrs| id == node_attrs.id }.outputs
  end.flatten(1)
end

Private Class Methods

for_semantic(outputs, semantic) click to toggle source

Apply to any array.

# File lib/trailblazer/activity/schema/intermediate.rb, line 91
                     def self.for_semantic(outputs, semantic)
  outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found"
end