igniter 0.2.0 → 0.3.0

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

@@ -24,9 +24,9 @@ module Igniter
 
         def explain_output(output_name)
           output = @execution.compiled_graph.fetch_output(output_name)
-          source = @execution.compiled_graph.fetch_node(output.source)
+          source = @execution.compiled_graph.fetch_node(output.source_root)
 
-          {
+          explanation = {
             output_id: output.id,
             output: output.name,
             path: output.path,
@@ -35,6 +35,13 @@ module Igniter
             source_path: source.path,
             dependencies: dependency_tree(source)
           }
+
+          if output.composition_output?
+            explanation[:child_output] = output.child_output_name
+            explanation[:child_output_path] = output.source.to_s
+          end
+
+          explanation
         end
 
         private
@@ -52,7 +59,7 @@ module Igniter
             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))
+              dependency_tree(@execution.compiled_graph.fetch_dependency(dependency_name))
             end
           }
         end
@@ -84,6 +91,14 @@ module Igniter
 
         def serialize_value(value)
           case value
+          when Igniter::Runtime::DeferredResult
+            {
+              type: :deferred,
+              token: value.token,
+              payload: value.payload,
+              source_node: value.source_node,
+              waiting_on: value.waiting_on
+            }
           when Igniter::Runtime::Result
             {
               type: :result,

data/lib/igniter/extensions/introspection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "introspection/graph_formatter"
+require_relative "introspection/plan_formatter"
 require_relative "introspection/runtime_formatter"
 
 module Igniter

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Igniter
   module Extensions
     module Reactive
@@ -11,16 +13,21 @@ module Igniter
           @contract = contract
           @reactions = reactions
           @errors = []
+          @fired_reactions = Set.new
         end
 
         def call(event)
           reactions.each do |reaction|
             next unless Matcher.new(reaction, event).match?
+            next if already_fired?(reaction, event)
 
-            reaction.action.call(
+            mark_fired(reaction, event)
+            call_action(
+              reaction.action,
               event: event,
               contract: contract,
-              execution: execution
+              execution: execution,
+              value: value_for(event)
             )
           rescue StandardError => e
             @errors << {
@@ -30,6 +37,46 @@ module Igniter
             }
           end
         end
+
+        private
+
+        def call_action(action, **kwargs)
+          parameters = action.parameters
+          accepts_any_keywords = parameters.any? { |kind, _name| kind == :keyrest }
+
+          if accepts_any_keywords
+            action.call(**kwargs)
+            return
+          end
+
+          accepted_keywords = parameters.select { |kind, _name| %i[key keyreq].include?(kind) }.map(&:last)
+          filtered_kwargs = kwargs.slice(*accepted_keywords)
+          action.call(**filtered_kwargs)
+        end
+
+        def value_for(event)
+          return nil unless %i[node_succeeded node_resumed node_pending].include?(event.type)
+          return nil unless event.node_name
+
+          state = execution.cache.fetch(event.node_name)
+          state&.value
+        end
+
+        def already_fired?(reaction, event)
+          return false unless reaction.once_per_execution
+
+          @fired_reactions.include?(reaction_key(reaction, event))
+        end
+
+        def mark_fired(reaction, event)
+          return unless reaction.once_per_execution
+
+          @fired_reactions << reaction_key(reaction, event)
+        end
+
+        def reaction_key(reaction, event)
+          [reaction.object_id, event.execution_id]
+        end
       end
     end
   end

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

@@ -4,12 +4,13 @@ module Igniter
   module Extensions
     module Reactive
       class Reaction
-        attr_reader :event_type, :path, :action
+        attr_reader :event_type, :path, :action, :once_per_execution
 
-        def initialize(event_type:, path: nil, action:)
+        def initialize(event_type:, path: nil, action:, once_per_execution: false)
           @event_type = event_type.to_sym
           @path = path&.to_s
           @action = action
+          @once_per_execution = once_per_execution
         end
       end
     end

data/lib/igniter/model/branch_node.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class BranchNode < Node
+      attr_reader :selector_dependency, :cases, :default_contract, :input_mapping
+
+      def initialize(id:, name:, selector_dependency:, cases:, default_contract:, input_mapping:, path: nil, metadata: {})
+        dependencies = ([selector_dependency] + input_mapping.values).uniq
+
+        super(
+          id: id,
+          kind: :branch,
+          name: name,
+          path: (path || name),
+          dependencies: dependencies,
+          metadata: metadata
+        )
+
+        @selector_dependency = selector_dependency.to_sym
+        @cases = cases.map { |entry| normalize_case(entry) }.freeze
+        @default_contract = default_contract
+        @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
+      end
+
+      def possible_contracts
+        (cases.map { |entry| entry[:contract] } + [default_contract]).uniq
+      end
+
+      private
+
+      def normalize_case(entry)
+        {
+          match: entry.fetch(:match),
+          contract: entry.fetch(:contract)
+        }
+      end
+    end
+  end
+end

data/lib/igniter/model/collection_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class CollectionNode < Node
+      attr_reader :source_dependency, :contract_class, :key_name, :mode
+
+      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, path: nil, metadata: {})
+        super(
+          id: id,
+          kind: :collection,
+          name: name,
+          path: (path || name),
+          dependencies: [source_dependency],
+          metadata: metadata
+        )
+
+        @source_dependency = source_dependency.to_sym
+        @contract_class = contract_class
+        @key_name = key_name.to_sym
+        @mode = mode.to_sym
+      end
+    end
+  end
+end

data/lib/igniter/model/composition_node.rb

@@ -5,12 +5,12 @@ module Igniter
     class CompositionNode < Node
       attr_reader :contract_class, :input_mapping
 
-      def initialize(id:, name:, contract_class:, input_mapping:, metadata: {})
+      def initialize(id:, name:, contract_class:, input_mapping:, path: nil, metadata: {})
         super(
           id: id,
           kind: :composition,
           name: name,
-          path: name,
+          path: (path || name),
           dependencies: input_mapping.values,
           metadata: metadata
         )

data/lib/igniter/model/compute_node.rb

@@ -5,17 +5,73 @@ module Igniter
     class ComputeNode < Node
       attr_reader :callable
 
-      def initialize(id:, name:, dependencies:, callable:, metadata: {})
+      def initialize(id:, name:, dependencies:, callable:, path: nil, metadata: {})
         super(
           id: id,
           kind: :compute,
           name: name,
-          path: name,
+          path: (path || name),
           dependencies: dependencies,
           metadata: metadata
         )
         @callable = callable
       end
+
+      def callable_name
+        return "const" if const?
+        return "guard" if guard?
+
+        case callable
+        when Proc
+          "proc"
+        when Symbol, String
+          callable.to_s
+        when Class
+          callable.name || "AnonymousClass"
+        else
+          callable.class.name || "AnonymousCallable"
+        end
+      end
+
+      def executor_key
+        metadata[:executor_key] || executor_metadata[:key]
+      end
+
+      def executor_label
+        metadata[:label] || executor_metadata[:label]
+      end
+
+      def executor_category
+        metadata[:category] || executor_metadata[:category]
+      end
+
+      def executor_tags
+        Array(metadata[:tags] || executor_metadata[:tags]).freeze
+      end
+
+      def executor_summary
+        metadata[:summary] || executor_metadata[:summary]
+      end
+
+      def type
+        metadata[:type] || executor_metadata[:type]
+      end
+
+      def const?
+        metadata[:kind] == :const
+      end
+
+      def guard?
+        metadata[:guard] == true || metadata[:kind] == :guard
+      end
+
+      private
+
+      def executor_metadata
+        return {} unless callable.is_a?(Class) && callable <= Igniter::Executor
+
+        callable.executor_metadata
+      end
     end
   end
 end

data/lib/igniter/model/input_node.rb

@@ -3,8 +3,8 @@
 module Igniter
   module Model
     class InputNode < Node
-      def initialize(id:, name:, metadata: {})
-        super(id: id, kind: :input, name: name, path: name, metadata: metadata)
+      def initialize(id:, name:, path: nil, metadata: {})
+        super(id: id, kind: :input, name: name, path: (path || name), metadata: metadata)
       end
 
       def type

data/lib/igniter/model/output_node.rb

@@ -5,16 +5,36 @@ module Igniter
     class OutputNode < Node
       attr_reader :source
 
-      def initialize(id:, name:, source:, metadata: {})
+      def initialize(id:, name:, source:, path: nil, metadata: {})
+        normalized_source = source.to_s
+
         super(
           id: id,
           kind: :output,
           name: name,
-          path: "output.#{name}",
-          dependencies: [source],
+          path: (path || "output.#{name}"),
+          dependencies: [normalized_source.split(".").first],
           metadata: metadata
         )
-        @source = source.to_sym
+        @source = normalized_source.include?(".") ? normalized_source : normalized_source.to_sym
+      end
+
+      def source_root
+        source.to_s.split(".").first.to_sym
+      end
+
+      def composition_output?
+        source.to_s.include?(".")
+      end
+
+      def type
+        metadata[:type]
+      end
+
+      def child_output_name
+        return unless composition_output?
+
+        source.to_s.split(".", 2).last.to_sym
       end
     end
   end

data/lib/igniter/model.rb

@@ -5,6 +5,8 @@ require_relative "model/graph"
 require_relative "model/input_node"
 require_relative "model/compute_node"
 require_relative "model/composition_node"
+require_relative "model/branch_node"
+require_relative "model/collection_node"
 require_relative "model/output_node"
 
 module Igniter

data/lib/igniter/runtime/cache.rb

@@ -5,47 +5,86 @@ module Igniter
     class Cache
       def initialize
         @states = {}
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
       end
 
       def fetch(node_name)
-        @states[node_name.to_sym]
+        @mutex.synchronize { @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
-        )
+        @mutex.synchronize do
+          current = @states[state.node.name]
+          version = state.version || (current&.running? ? current.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
+          )
+          @condition.broadcast
+        end
+      end
+
+      def begin_resolution(node)
+        @mutex.synchronize do
+          loop do
+            current = @states[node.name]
+            return [:cached, current] if current && !current.stale? && !current.running?
+
+            unless current&.running?
+              @states[node.name] = NodeState.new(
+                node: node,
+                status: :running,
+                value: current&.value,
+                error: current&.error,
+                version: next_version(current),
+                resolved_at: current&.resolved_at || Time.now.utc,
+                invalidated_by: nil
+              )
+              return [:started, @states[node.name]]
+            end
+
+            @condition.wait(@mutex)
+          end
+        end
       end
 
       def stale!(node, invalidated_by:)
-        current = fetch(node.name)
-        return unless current
+        @mutex.synchronize do
+          current = @states[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
-        )
+          @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
+          )
+          @condition.broadcast
+        end
       end
 
       def values
-        @states.values
+        @mutex.synchronize { @states.values }
       end
 
       def to_h
-        @states.dup
+        @mutex.synchronize { @states.dup }
+      end
+
+      def restore!(states)
+        @mutex.synchronize do
+          @states = states.transform_keys(&:to_sym)
+          @condition.broadcast
+        end
       end
 
       private

data/lib/igniter/runtime/collection_result.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class CollectionResult
+      Item = Struct.new(:key, :status, :result, :error, keyword_init: true) do
+        def succeeded?
+          status == :succeeded
+        end
+
+        def failed?
+          status == :failed
+        end
+
+        def to_h
+          {
+            key: key,
+            status: status,
+            result: serialize_result(result),
+            error: serialize_error(error)
+          }.compact
+        end
+
+        private
+
+        def serialize_result(value)
+          case value
+          when Runtime::Result
+            value.to_h
+          else
+            value
+          end
+        end
+
+        def serialize_error(value)
+          return nil unless value
+
+          {
+            type: value.class.name,
+            message: value.message,
+            context: value.respond_to?(:context) ? value.context : {}
+          }
+        end
+      end
+
+      attr_reader :items, :mode
+
+      def initialize(items:, mode:)
+        @items = items.freeze
+        @mode = mode.to_sym
+      end
+
+      def [](key)
+        items.fetch(key)
+      end
+
+      def keys
+        items.keys
+      end
+
+      def successes
+        items.select { |_key, item| item.succeeded? }
+      end
+
+      def failures
+        items.select { |_key, item| item.failed? }
+      end
+
+      def items_summary
+        items.transform_values do |item|
+          {
+            status: item.status,
+            error: item.error&.message
+          }.compact
+        end
+      end
+
+      def failed_items
+        failures.transform_values do |item|
+          {
+            type: item.error.class.name,
+            message: item.error.message,
+            context: item.error.respond_to?(:context) ? item.error.context : {}
+          }
+        end
+      end
+
+      def to_h
+        items.transform_values(&:to_h)
+      end
+
+      def summary
+        {
+          mode: mode,
+          total: items.size,
+          succeeded: successes.size,
+          failed: failures.size,
+          status: failures.empty? ? :succeeded : :partial_failure
+        }
+      end
+
+      def as_json(*)
+        {
+          mode: mode,
+          summary: summary,
+          items: to_h
+        }
+      end
+    end
+  end
+end

data/lib/igniter/runtime/deferred_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Igniter
+  module Runtime
+    class DeferredResult
+      attr_reader :token, :payload, :source_node, :waiting_on
+
+      def initialize(token:, payload: {}, source_node: nil, waiting_on: nil)
+        @token = token
+        @payload = payload.freeze
+        @source_node = source_node&.to_sym
+        @waiting_on = waiting_on&.to_sym
+      end
+
+      def self.build(token: nil, payload: {}, source_node: nil, waiting_on: nil)
+        new(
+          token: token || SecureRandom.uuid,
+          payload: payload,
+          source_node: source_node,
+          waiting_on: waiting_on
+        )
+      end
+
+      def to_h
+        {
+          token: token,
+          payload: payload,
+          source_node: source_node,
+          waiting_on: waiting_on
+        }.compact
+      end
+
+      def as_json(*)
+        to_h
+      end
+    end
+  end
+end