Module: Igniter::Contracts::Assembly::BaselinePack

Defined in:
lib/igniter/contracts/assembly/baseline_pack.rb

Constant Summary collapse

BASELINE_NODE_KINDS = 
{
  input: NodeType.new(kind: :input, metadata: { category: :data }),
  const: NodeType.new(kind: :const, metadata: { category: :value }),
  compute: NodeType.new(kind: :compute, metadata: { category: :data }),
  effect: NodeType.new(kind: :effect, metadata: { category: :effect }),
  output: NodeType.new(kind: :output, metadata: { category: :terminal })
}.freeze
BASELINE_DSL_KEYWORDS = 
{
  input: DslKeyword.new(:input, lambda { |name, builder:, **attributes|
    builder.add_operation(kind: :input, name: name, **attributes)
  }),
  const: DslKeyword.new(:const, lambda { |name, value, builder:|
    builder.add_operation(kind: :const, name: name, value: value)
  }),
  compute: DslKeyword.new(:compute, lambda { |name, builder:, **attributes, &block|
    normalized_attributes = attributes.dup
    normalized_attributes[:callable] = normalized_attributes.delete(:call) if normalized_attributes.key?(:call)
    if normalized_attributes.key?(:using)
      target = normalized_attributes.delete(:using)
      output_name = normalized_attributes.delete(:output)&.to_sym
      normalized_attributes[:callable] = lambda do |**values|
        payload = Contractable.invoke(target, **values).to_h
        output_name && payload.fetch(:success) ? payload.fetch(:outputs).fetch(output_name) : payload
      end
    end
    normalized_attributes[:callable] = block if block
    builder.add_operation(kind: :compute, name: name, **normalized_attributes)
  }),
  effect: DslKeyword.new(:effect, lambda { |name, using:, builder:, callable: nil, **attributes, &block|
    normalized_attributes = attributes.dup
    normalized_attributes[:using] = using.to_sym
    normalized_attributes[:callable] = block if block
    normalized_attributes[:callable] = callable if callable && !block
    builder.add_operation(kind: :effect, name: name, **normalized_attributes)
  }),
  output: DslKeyword.new(:output, lambda { |name, builder:, **attributes|
    builder.add_operation(kind: :output, name: name, **attributes)
  })
}.freeze
BASELINE_DIAGNOSTICS = 
{
  baseline_summary: Module.new do
    module_function

    def augment(report:, result:, profile:) # rubocop:disable Lint/UnusedMethodArgument
      report.add_section(:baseline_summary, {
                           outputs: result.outputs.keys.sort,
                           state: result.state.keys.sort
                         })
    end
  end
}.freeze

Class Method Summary collapse

Class Method Details

.install_diagnostics(kernel) ⇒ Object 



133
134
135
136
137
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 133

def install_diagnostics(kernel)
  BASELINE_DIAGNOSTICS.each do |key, value|
    kernel.diagnostics_contributors.register(key, value)
  end
end

.install_dsl_keywords(kernel) ⇒ Object 



100
101
102
103
104
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 100

def install_dsl_keywords(kernel)
  BASELINE_DSL_KEYWORDS.each do |key, value|
    kernel.dsl_keywords.register(key, value)
  end
end

.install_executors(kernel) ⇒ Object 



129
130
131
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 129

def install_executors(kernel)
  kernel.executors.register(:inline, Execution::InlineExecutor.method(:call))
end

.install_into(kernel) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 83

def install_into(kernel)
  install_nodes(kernel)
  install_dsl_keywords(kernel)
  install_normalizers(kernel)
  install_validators(kernel)
  install_runtime_handlers(kernel)
  install_executors(kernel)
  install_diagnostics(kernel)
  kernel
end

.install_nodes(kernel) ⇒ Object 



94
95
96
97
98
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 94

def install_nodes(kernel)
  BASELINE_NODE_KINDS.each do |key, value|
    kernel.nodes.register(key, value)
  end
end

.install_normalizers(kernel) ⇒ Object 



106
107
108
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 106

def install_normalizers(kernel)
  kernel.normalizers.register(:normalize_operation_attributes, Execution::BaselineNormalizers.method(:normalize_operation_attributes))
end

.install_runtime_handlers(kernel) ⇒ Object 



121
122
123
124
125
126
127
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 121

def install_runtime_handlers(kernel)
  kernel.runtime_handlers.register(:input, Execution::BaselineRuntime.method(:handle_input))
  kernel.runtime_handlers.register(:const, Execution::ConstRuntime.method(:handle_const))
  kernel.runtime_handlers.register(:compute, Execution::BaselineRuntime.method(:handle_compute))
  kernel.runtime_handlers.register(:effect, Execution::BaselineRuntime.method(:handle_effect))
  kernel.runtime_handlers.register(:output, Execution::BaselineRuntime.method(:handle_output))
end

.install_validators(kernel) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 110

def install_validators(kernel)
  kernel.validators.register(:uniqueness, Execution::BaselineValidators.method(:validate_uniqueness))
  kernel.validators.register(:outputs, Execution::BaselineValidators.method(:validate_outputs))
  kernel.validators.register(:dependencies, Execution::BaselineValidators.method(:validate_dependencies))
  kernel.validators.register(:callables, Execution::BaselineValidators.method(:validate_callables))
  kernel.validators.register(:effect_dependencies, Execution::BaselineValidators.method(:validate_effect_dependencies))
  kernel.validators.register(:effect_payload_builders, Execution::BaselineValidators.method(:validate_effect_payload_builders))
  kernel.validators.register(:effect_adapters, Execution::BaselineValidators.method(:validate_effect_adapters))
  kernel.validators.register(:types, Execution::BaselineValidators.method(:validate_types))
end

.manifest ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/igniter/contracts/assembly/baseline_pack.rb', line 9

def manifest
  PackManifest.new(
    name: :baseline,
    node_contracts: BASELINE_NODE_KINDS.keys.map { |kind| PackManifest.node(kind) },
    registry_contracts: [
      PackManifest.normalizer(:normalize_operation_attributes),
      PackManifest.validator(:uniqueness),
      PackManifest.validator(:outputs),
      PackManifest.validator(:dependencies),
      PackManifest.validator(:callables),
      PackManifest.validator(:effect_dependencies),
      PackManifest.validator(:effect_payload_builders),
      PackManifest.validator(:effect_adapters),
      PackManifest.validator(:types),
      PackManifest.executor(:inline),
      PackManifest.diagnostic(:baseline_summary)
    ]
  )
end