igniter 0.2.0

data/lib/igniter/extensions/introspection/runtime_formatter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Introspection
+      class RuntimeFormatter
+        def self.states(execution)
+          new(execution).states
+        end
+
+        def self.explain_output(execution, output_name)
+          new(execution).explain_output(output_name)
+        end
+
+        def initialize(execution)
+          @execution = execution
+        end
+
+        def states
+          @execution.cache.to_h.each_with_object({}) do |(node_name, state), memo|
+            memo[node_name] = serialize_state(state)
+          end
+        end
+
+        def explain_output(output_name)
+          output = @execution.compiled_graph.fetch_output(output_name)
+          source = @execution.compiled_graph.fetch_node(output.source)
+
+          {
+            output_id: output.id,
+            output: output.name,
+            path: output.path,
+            source_id: source.id,
+            source: source.name,
+            source_path: source.path,
+            dependencies: dependency_tree(source)
+          }
+        end
+
+        private
+
+        def dependency_tree(node)
+          state = @execution.cache.fetch(node.name)
+          {
+            id: node.id,
+            name: node.name,
+            path: node.path,
+            kind: node.kind,
+            source_location: node.source_location,
+            status: state&.status,
+            invalidated_by: invalidation_details(state),
+            value: serialize_value(state&.value),
+            error: state&.error&.message,
+            dependencies: node.dependencies.map do |dependency_name|
+              dependency_tree(@execution.compiled_graph.fetch_node(dependency_name))
+            end
+          }
+        end
+
+        def serialize_state(state)
+          {
+            id: state.node.id,
+            path: state.node.path,
+            kind: state.node.kind,
+            source_location: state.node.source_location,
+            status: state.status,
+            version: state.version,
+            invalidated_by: invalidation_details(state),
+            value: serialize_value(state.value),
+            error: state.error&.message
+          }
+        end
+
+        def invalidation_details(state)
+          return nil unless state&.invalidated_by
+
+          invalidating_node = @execution.compiled_graph.fetch_node(state.invalidated_by)
+          {
+            node_id: invalidating_node.id,
+            node_name: invalidating_node.name,
+            node_path: invalidating_node.path
+          }
+        end
+
+        def serialize_value(value)
+          case value
+          when Igniter::Runtime::Result
+            {
+              type: :result,
+              graph: value.execution.compiled_graph.name,
+              execution_id: value.execution.events.execution_id
+            }
+          when Array
+            value.map { |item| serialize_value(item) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/introspection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "introspection/graph_formatter"
+require_relative "introspection/runtime_formatter"
+
+module Igniter
+  module Extensions
+    module Introspection
+    end
+  end
+end

data/lib/igniter/extensions/reactive/engine.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Reactive
+      class Engine
+        attr_reader :execution, :contract, :reactions, :errors
+
+        def initialize(execution:, contract:, reactions:)
+          @execution = execution
+          @contract = contract
+          @reactions = reactions
+          @errors = []
+        end
+
+        def call(event)
+          reactions.each do |reaction|
+            next unless Matcher.new(reaction, event).match?
+
+            reaction.action.call(
+              event: event,
+              contract: contract,
+              execution: execution
+            )
+          rescue StandardError => e
+            @errors << {
+              event: event,
+              reaction: reaction,
+              error: e
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/reactive/matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Reactive
+      class Matcher
+        def initialize(reaction, event)
+          @reaction = reaction
+          @event = event
+        end
+
+        def match?
+          return false unless @reaction.event_type == @event.type
+          return true unless @reaction.path
+
+          @reaction.path == @event.path
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/reactive/reaction.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Reactive
+      class Reaction
+        attr_reader :event_type, :path, :action
+
+        def initialize(event_type:, path: nil, action:)
+          @event_type = event_type.to_sym
+          @path = path&.to_s
+          @action = action
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/reactive.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "reactive/reaction"
+require_relative "reactive/matcher"
+require_relative "reactive/engine"
+
+module Igniter
+  module Extensions
+    module Reactive
+    end
+  end
+end

data/lib/igniter/extensions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "extensions/auditing"
+require_relative "extensions/reactive"
+require_relative "extensions/introspection"
+
+module Igniter
+  module Extensions
+  end
+end

data/lib/igniter/model/composition_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class CompositionNode < Node
+      attr_reader :contract_class, :input_mapping
+
+      def initialize(id:, name:, contract_class:, input_mapping:, metadata: {})
+        super(
+          id: id,
+          kind: :composition,
+          name: name,
+          path: name,
+          dependencies: input_mapping.values,
+          metadata: metadata
+        )
+        @contract_class = contract_class
+        @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
+      end
+    end
+  end
+end

data/lib/igniter/model/compute_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class ComputeNode < Node
+      attr_reader :callable
+
+      def initialize(id:, name:, dependencies:, callable:, metadata: {})
+        super(
+          id: id,
+          kind: :compute,
+          name: name,
+          path: name,
+          dependencies: dependencies,
+          metadata: metadata
+        )
+        @callable = callable
+      end
+    end
+  end
+end

data/lib/igniter/model/graph.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class Graph
+      attr_reader :name, :nodes, :metadata
+
+      def initialize(name:, nodes:, metadata: {})
+        @name = name
+        @nodes = nodes.freeze
+        @metadata = metadata.freeze
+      end
+    end
+  end
+end

data/lib/igniter/model/input_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class InputNode < Node
+      def initialize(id:, name:, metadata: {})
+        super(id: id, kind: :input, name: name, path: name, metadata: metadata)
+      end
+
+      def type
+        metadata[:type]
+      end
+
+      def required?
+        metadata.fetch(:required, !metadata.key?(:default))
+      end
+
+      def default?
+        metadata.key?(:default)
+      end
+
+      def default
+        metadata[:default]
+      end
+    end
+  end
+end

data/lib/igniter/model/node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class Node
+      attr_reader :id, :kind, :name, :path, :dependencies, :metadata
+
+      def initialize(id:, kind:, name:, path:, dependencies: [], metadata: {})
+        @id = id
+        @kind = kind
+        @name = name.to_sym
+        @path = path.to_s
+        @dependencies = dependencies.map(&:to_sym).freeze
+        @metadata = metadata.freeze
+      end
+
+      def source_location
+        metadata[:source_location]
+      end
+    end
+  end
+end

data/lib/igniter/model/output_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class OutputNode < Node
+      attr_reader :source
+
+      def initialize(id:, name:, source:, metadata: {})
+        super(
+          id: id,
+          kind: :output,
+          name: name,
+          path: "output.#{name}",
+          dependencies: [source],
+          metadata: metadata
+        )
+        @source = source.to_sym
+      end
+    end
+  end
+end

data/lib/igniter/model.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "model/node"
+require_relative "model/graph"
+require_relative "model/input_node"
+require_relative "model/compute_node"
+require_relative "model/composition_node"
+require_relative "model/output_node"
+
+module Igniter
+  module Model
+  end
+end

data/lib/igniter/runtime/cache.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class Cache
+      def initialize
+        @states = {}
+      end
+
+      def fetch(node_name)
+        @states[node_name.to_sym]
+      end
+
+      def write(state)
+        current = fetch(state.node.name)
+        version = state.version || next_version(current)
+        @states[state.node.name] = NodeState.new(
+          node: state.node,
+          status: state.status,
+          value: state.value,
+          error: state.error,
+          version: version,
+          resolved_at: state.resolved_at,
+          invalidated_by: state.invalidated_by
+        )
+      end
+
+      def stale!(node, invalidated_by:)
+        current = fetch(node.name)
+        return unless current
+
+        @states[node.name] = NodeState.new(
+          node: node,
+          status: :stale,
+          value: current.value,
+          error: current.error,
+          version: current.version + 1,
+          resolved_at: current.resolved_at,
+          invalidated_by: invalidated_by
+        )
+      end
+
+      def values
+        @states.values
+      end
+
+      def to_h
+        @states.dup
+      end
+
+      private
+
+      def next_version(current)
+        current ? current.version + 1 : 1
+      end
+    end
+  end
+end

data/lib/igniter/runtime/execution.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class Execution
+      attr_reader :compiled_graph, :contract_instance, :inputs, :cache, :events, :audit
+
+      def initialize(compiled_graph:, contract_instance:, inputs:)
+        @compiled_graph = compiled_graph
+        @contract_instance = contract_instance
+        @input_validator = InputValidator.new(compiled_graph)
+        @inputs = @input_validator.normalize_initial_inputs(inputs)
+        @cache = Cache.new
+        @events = Events::Bus.new
+        @audit = Extensions::Auditing::Timeline.new(self)
+        @events.subscribe(@audit)
+        @resolver = Resolver.new(self)
+        @invalidator = Invalidator.new(self)
+      end
+
+      def resolve_output(name)
+        output = compiled_graph.fetch_output(name)
+        with_execution_lifecycle([output.source]) do
+          state = @resolver.resolve(output.source)
+          raise state.error if state.failed?
+
+          state.value
+        end
+      end
+
+      def resolve(name)
+        @resolver.resolve(name)
+      end
+
+      def resolve_all
+        output_sources = compiled_graph.outputs.map(&:source)
+
+        with_execution_lifecycle(output_sources) do
+          compiled_graph.outputs.each { |output_node| resolve(output_node.source) }
+          self
+        end
+      end
+
+      def update_inputs(new_inputs)
+        symbolize_keys(new_inputs).each do |name, value|
+          @input_validator.validate_update!(name, value)
+
+          @inputs[name] = value
+          input_node = compiled_graph.fetch_node(name)
+          cache.write(NodeState.new(node: input_node, status: :succeeded, value: value, invalidated_by: name))
+          @events.emit(:input_updated, node: input_node, status: :succeeded, payload: { value: value })
+          @invalidator.invalidate_from(name)
+        end
+
+        self
+      end
+
+      def success?
+        resolve_all
+        !cache.values.any?(&:failed?)
+      end
+
+      def failed?
+        resolve_all
+        cache.values.any?(&:failed?)
+      end
+
+      def states
+        Extensions::Introspection::RuntimeFormatter.states(self)
+      end
+
+      def explain_output(name)
+        Extensions::Introspection::RuntimeFormatter.explain_output(self, name)
+      end
+
+      def diagnostics
+        Diagnostics::Report.new(self)
+      end
+
+      def to_h
+        {
+          graph: compiled_graph.name,
+          execution_id: events.execution_id,
+          inputs: inputs.dup,
+          success: !cache.values.any?(&:failed?),
+          failed: cache.values.any?(&:failed?),
+          states: states,
+          event_count: events.events.size
+        }
+      end
+
+      def as_json(*)
+        to_h.merge(
+          events: events.events.map(&:as_json)
+        )
+      end
+
+      private
+
+      def with_execution_lifecycle(node_names)
+        if resolution_required_for_any?(node_names)
+          @events.emit(:execution_started, payload: { graph: compiled_graph.name, targets: node_names.map(&:to_sym) })
+          begin
+            result = yield
+            @events.emit(:execution_finished, payload: { graph: compiled_graph.name, targets: node_names.map(&:to_sym) })
+            result
+          rescue StandardError => e
+            @events.emit(
+              :execution_failed,
+              status: :failed,
+              payload: {
+                graph: compiled_graph.name,
+                targets: node_names.map(&:to_sym),
+                error: e.message
+              }
+            )
+            raise
+          end
+        else
+          yield
+        end
+      end
+
+      def resolution_required_for_any?(node_names)
+        node_names.any? do |node_name|
+          state = cache.fetch(node_name)
+          state.nil? || state.stale?
+        end
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
+      end
+
+      public
+
+      def fetch_input!(name)
+        @input_validator.fetch_value!(name, @inputs)
+      end
+    end
+  end
+end