igniter 0.2.0 → 0.3.0

data/lib/igniter/contract.rb

@@ -7,16 +7,102 @@ module Igniter
         @compiled_graph = DSL::ContractBuilder.compile(name: contract_name, &block)
       end
 
-      def react_to(event_type, path: nil, &block)
+      def run_with(runner:, max_workers: nil)
+        @execution_options = { runner: runner, max_workers: max_workers }.compact
+      end
+
+      def restore_from_store(execution_id, store: nil)
+        snapshot = (store || Igniter.execution_store).fetch(execution_id)
+        restore(snapshot)
+      end
+
+      def resume_from_store(execution_id, token:, value:, store: nil)
+        Runtime::JobWorker.new(self, store: store || Igniter.execution_store).resume(
+          execution_id: execution_id,
+          token: token,
+          value: value
+        )
+      end
+
+      def define_schema(schema)
+        @compiled_graph = DSL::SchemaBuilder.compile(schema, name: contract_name)
+      end
+
+      def restore(snapshot)
+        instance = new(
+          snapshot[:inputs] || snapshot["inputs"] || {},
+          runner: snapshot[:runner] || snapshot["runner"],
+          max_workers: snapshot[:max_workers] || snapshot["max_workers"]
+        )
+        instance.restore_execution(snapshot)
+      end
+
+      def react_to(event_type, path: nil, once_per_execution: false, &block)
         raise CompileError, "react_to requires a block" unless block
 
         reactions << Extensions::Reactive::Reaction.new(
           event_type: event_type,
           path: path,
-          action: block
+          action: block,
+          once_per_execution: once_per_execution
         )
       end
 
+      def effect(path = nil, event_type: :node_succeeded, &block)
+        react_to(event_type, path: path, &block)
+      end
+
+      def on_success(target, &block)
+        graph = compiled_graph
+        if graph&.output?(target)
+          react_to(:execution_finished, once_per_execution: true) do |event:, contract:, execution:|
+            next if execution.cache.values.any?(&:failed?)
+            next if execution.cache.values.any?(&:pending?)
+
+            block.call(
+              event: event,
+              contract: contract,
+              execution: execution,
+              value: contract.result.public_send(target)
+            )
+          end
+        else
+          effect(target.to_s, event_type: :node_succeeded, &block)
+        end
+      end
+
+      def on_failure(&block)
+        react_to(:execution_failed, once_per_execution: true) do |event:, contract:, execution:|
+          block.call(
+            event: event,
+            contract: contract,
+            execution: execution,
+            status: :failed,
+            errors: terminal_errors(execution),
+            error: terminal_errors(execution).values.first
+          )
+        end
+      end
+
+      def on_exit(&block)
+        terminal_hook = proc do |event:, contract:, execution:|
+          status = event.type == :execution_failed ? :failed : :succeeded
+          errors = status == :failed ? terminal_errors(execution) : {}
+
+          block.call(
+            event: event,
+            contract: contract,
+            execution: execution,
+            status: status,
+            errors: errors,
+            error: errors.values.first
+          )
+        end
+
+        react_to(:execution_finished, once_per_execution: true, &terminal_hook)
+        react_to(:execution_failed, once_per_execution: true, &terminal_hook)
+      end
+
       def compiled_graph
         @compiled_graph || superclass_compiled_graph
       end
@@ -26,6 +112,10 @@ module Igniter
         @reactions ||= []
       end
 
+      def execution_options
+        @execution_options || superclass_execution_options || {}
+      end
+
       private
 
       def contract_name
@@ -37,18 +127,47 @@ module Igniter
 
         superclass.compiled_graph
       end
+
+      def superclass_execution_options
+        return unless superclass.respond_to?(:execution_options)
+
+        superclass.execution_options
+      end
+
+      def terminal_errors(execution)
+        execution.cache.values.each_with_object({}) do |state, memo|
+          next unless state.failed?
+
+          memo[state.node.name] = state.error
+        end
+      end
     end
 
     attr_reader :execution, :result
 
-    def initialize(inputs = {})
+    def initialize(inputs = nil, runner: nil, max_workers: nil, **keyword_inputs)
       graph = self.class.compiled_graph
       raise CompileError, "#{self.class.name} has no compiled graph. Use `define`." unless graph
 
+      normalized_inputs =
+        if inputs.nil?
+          keyword_inputs
+        elsif keyword_inputs.empty?
+          inputs
+        else
+          inputs.to_h.merge(keyword_inputs)
+        end
+
+      execution_options = self.class.execution_options.merge(
+        { runner: runner, max_workers: max_workers }.compact
+      )
+      execution_options[:store] ||= Igniter.execution_store if execution_options[:runner]&.to_sym == :store
+
       @execution = Runtime::Execution.new(
         compiled_graph: graph,
         contract_instance: self,
-        inputs: inputs
+        inputs: normalized_inputs,
+        **execution_options
       )
       @reactive = Extensions::Reactive::Engine.new(
         execution: @execution,
@@ -98,6 +217,15 @@ module Igniter
       Diagnostics::Report.new(execution)
     end
 
+    def snapshot
+      execution.snapshot
+    end
+
+    def restore_execution(snapshot)
+      execution.restore!(snapshot)
+      self
+    end
+
     def diagnostics_text
       diagnostics.to_text
     end
@@ -106,6 +234,10 @@ module Igniter
       diagnostics.to_markdown
     end
 
+    def explain_plan(output_names = nil)
+      execution.explain_plan(output_names)
+    end
+
     def success?
       execution.success?
     end

data/lib/igniter/diagnostics/auditing/report/console_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Igniter
+  module Diagnostics
+    module Auditing
+      module Report
+        # Generates a human-readable text tree of an audition step.
+        class ConsoleFormatter
+          def self.call(player)
+            new(player).call
+          end
+
+          def initialize(player)
+            @player = player
+            @buffer = StringIO.new
+            @definition_graph = player.definition_graph
+            @audited_graph = player.current_graph
+          end
+
+          def call
+            print_header
+
+            @definition_graph.root_nodes.each do |node_def|
+              build_node_tree(node_def, prefix: "")
+            end
+
+            @buffer.string
+          end
+
+          private
+
+          def print_header
+            trigger = @audited_graph.triggering_event
+            @buffer.puts "--- Audition for #{@player.record.contract_class_name} ---"
+            @buffer.puts "Step: #{@audited_graph.version} / #{@player.versions_count}"
+            @buffer.puts "Trigger: #{trigger[:type]} on '#{trigger[:path]}'" if trigger
+            @buffer.puts "-------------------------------------------------"
+          end
+
+          def build_node_tree(node_def, prefix:)
+            children_defs = @definition_graph.children_of(node_def)
+            is_last = (node_def.parent ? @definition_graph.children_of(node_def.parent) : @definition_graph.root_nodes).last == node_def
+
+            @buffer << prefix
+            @buffer << (is_last ? "└── " : "├── ")
+            @buffer << "#{node_def.name} [#{node_def.class.name.split('::').last}]"
+
+            append_node_details(node_def)
+
+            @buffer << "\n"
+
+            new_prefix = prefix + (is_last ? "    " : "│   ")
+            children_defs.each do |child_def|
+              build_node_tree(child_def, prefix: new_prefix)
+            end
+          end
+
+          def append_node_details(node_def)
+            audited_node = @audited_graph.find(node_def.path)
+            if audited_node
+              status_icon = case audited_node.status.to_sym
+                            when :success then "✓"
+                            when :failure then "✗"
+                            when :invalidated then "~"
+                            else "?"
+                            end
+              @buffer << " [#{status_icon}]"
+              @buffer << " => <#{audited_node.value_class}> #{audited_node.value.to_s.truncate(100)}"
+              @buffer << " (Errors: #{audited_node.errors.join(', ')})" if audited_node.status.to_sym == :failure
+            else
+              @buffer << " [Not Present in History]"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/diagnostics/auditing/report/markdown_formatter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module Auditing
+      module Report
+        class MarkdownFormatter
+          def self.call(player)
+            new(player).call
+          end
+
+          def initialize(player)
+            @player = player
+            @definition_graph = player.definition_graph
+            @audited_graph = player.current_graph
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/igniter/diagnostics/introspection/formatters/mermaid_formatter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module Introspection
+      module Formatters
+        class MermaidFormatter
+          def self.call(structure)
+            new(structure).call
+          end
+
+          def initialize(structure)
+            @structure = structure
+            @output = StringIO.new
+          end
+
+          def call
+            # Устанавливаем направление диаграммы слева направо
+            @output.puts "graph LR"
+            @output.puts "classDef default fill:#fff,stroke:#333,stroke-width:2px;"
+
+            # Запускаем рекурсивную отрисовку
+            draw_nodes_and_links(@structure)
+
+            @output.string
+          end
+
+          private
+
+          def draw_nodes_and_links(nodes)
+            nodes.each do |node|
+              # 1. Если узел - это Namespace, создаем для него subgraph
+              if node[:type] == "Namespace"
+                @output.puts "  subgraph #{node[:name]}"
+                # Рекурсивно отрисовываем всех детей внутри подграфа
+                draw_nodes_and_links(node[:children])
+                @output.puts "  end"
+              else
+                # 2. Если это обычный узел, просто объявляем его
+                node_text = "\"#{node[:name]}<br>[#{node[:details]}]\""
+                @output.puts "  #{node[:path]}(#{node_text})"
+
+                # У обычного узла тоже могут быть дети (например, проекции у композиции),
+                # их тоже нужно отрисовать.
+                draw_nodes_and_links(node[:children])
+              end
+
+              # 3. После объявления узла (или целого подграфа) рисуем его зависимости
+              node[:dependencies].each do |dep_path|
+                @output.puts "  #{dep_path} --> #{node[:path]}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/diagnostics/introspection/formatters/text_tree_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module Introspection
+      module Formatters
+        class TextTreeFormatter
+          def self.call(structure)
+            new(structure).call
+          end
+
+          def initialize(structure)
+            @structure = structure
+            @output = StringIO.new
+          end
+
+          def call
+            @structure.each_with_index do |node, index|
+              is_last = index == @structure.size - 1
+              print_node(node, "", is_last)
+            end
+            @output.string
+          end
+
+          private
+
+          def print_node(node, prefix, is_last)
+            connector = is_last ? "└── " : "├── "
+            @output << "#{prefix}#{connector}#{node[:name]} [#{node[:type]}] #{node[:details]}\n"
+
+            children_prefix = prefix + (is_last ? "    " : "│   ")
+            if node[:dependencies].any?
+              @output << "#{children_prefix}  └─ depends_on: [#{node[:dependencies].join(', ')}]\n"
+            end
+
+            node[:children].each_with_index do |child, index|
+              print_node(child, children_prefix, index == node[:children].size - 1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/diagnostics/report.rb

@@ -17,6 +17,7 @@ module Igniter
           outputs: serialize_outputs,
           errors: serialize_errors,
           nodes: summarize_nodes,
+          collection_nodes: summarize_collection_nodes,
           events: summarize_events
         }
       end
@@ -33,6 +34,7 @@ module Igniter
         lines << "Status: #{report[:status]}"
         lines << format_outputs(report[:outputs])
         lines << format_nodes(report[:nodes])
+        lines << format_collection_nodes(report[:collection_nodes])
         lines << format_errors(report[:errors])
         lines << format_events(report[:events])
         lines.compact.join("\n")
@@ -47,6 +49,9 @@ module Igniter
         lines << "- Status: `#{report[:status]}`"
         lines << "- Outputs: #{inline_hash(report[:outputs])}"
         lines << "- Nodes: total=#{report[:nodes][:total]}, succeeded=#{report[:nodes][:succeeded]}, failed=#{report[:nodes][:failed]}, stale=#{report[:nodes][:stale]}"
+        unless report[:collection_nodes].empty?
+          lines << "- Collections: #{report[:collection_nodes].map { |node| "#{node[:node_name]} total=#{node[:total]} succeeded=#{node[:succeeded]} failed=#{node[:failed]} status=#{node[:status]}" }.join('; ')}"
+        end
         lines << "- Events: total=#{report[:events][:total]}, latest=#{report[:events][:latest_type] || 'none'}"
 
         unless report[:errors].empty?
@@ -57,6 +62,17 @@ module Igniter
           end
         end
 
+        unless report[:collection_nodes].empty?
+          lines << ""
+          lines << "## Collections"
+          report[:collection_nodes].each do |node|
+            lines << "- `#{node[:node_name]}`: total=#{node[:total]}, succeeded=#{node[:succeeded]}, failed=#{node[:failed]}, status=#{node[:status]}"
+            node[:failed_items].each do |item|
+              lines << "- `#{node[:node_name]}[#{item[:key]}]` failed: #{item[:message]}"
+            end
+          end
+        end
+
         lines.join("\n")
       end
 
@@ -76,36 +92,52 @@ module Igniter
 
       def status
         return :failed if execution.cache.values.any?(&:failed?)
+        return :pending if execution.cache.values.any?(&:pending?)
         return :stale if execution.cache.values.any?(&:stale?)
 
         :succeeded
       end
 
       def serialize_errors
-        execution_result.errors.map do |node_name, error|
+        execution.cache.values.filter_map do |state|
+          next unless state.failed?
+
           {
-            node_name: node_name,
-            type: error.class.name,
-            message: error.message,
-            context: error.respond_to?(:context) ? error.context : {}
+            node_name: state.node.name,
+            type: state.error.class.name,
+            message: state.error.message,
+            context: state.error.respond_to?(:context) ? state.error.context : {}
           }
         end
       end
 
       def serialize_outputs
         execution.compiled_graph.outputs.each_with_object({}) do |output_node, memo|
-          state = execution.cache.fetch(output_node.source)
-          memo[output_node.name] = serialize_output_state(state)
+          state = execution.cache.fetch(output_node.source_root)
+          memo[output_node.name] = serialize_output_value(output_node, state)
         end
       end
 
-      def serialize_output_state(state)
+      def serialize_output_value(output_node, state)
         return nil unless state
         return { error: state.error.message, status: state.status } if state.failed?
 
+        if output_node.composition_output?
+          return serialize_output_from_child(output_node, state.value)
+        end
+
         serialize_value(state.value)
       end
 
+      def serialize_output_from_child(output_node, child_result)
+        return nil unless child_result.is_a?(Runtime::Result)
+
+        child_errors = child_result.execution.cache.values.select(&:failed?)
+        return { error: child_errors.first.error.message, status: :failed } unless child_errors.empty?
+
+        child_result.public_send(output_node.child_output_name)
+      end
+
       def summarize_nodes
         states = execution.states
 
@@ -113,6 +145,7 @@ module Igniter
           total: states.size,
           succeeded: states.values.count { |state| state[:status] == :succeeded },
           failed: states.values.count { |state| state[:status] == :failed },
+          pending: states.values.count { |state| state[:status] == :pending },
           stale: states.values.count { |state| state[:status] == :stale },
           failed_nodes: states.filter_map do |node_name, state|
             next unless state[:status] == :failed
@@ -139,6 +172,7 @@ module Igniter
 
       def format_nodes(nodes)
         line = "Nodes: total=#{nodes[:total]}, succeeded=#{nodes[:succeeded]}, failed=#{nodes[:failed]}, stale=#{nodes[:stale]}"
+        line = "Nodes: total=#{nodes[:total]}, succeeded=#{nodes[:succeeded]}, failed=#{nodes[:failed]}, pending=#{nodes[:pending]}, stale=#{nodes[:stale]}"
         return line if nodes[:failed_nodes].empty?
 
         failures = nodes[:failed_nodes].map { |node| "#{node[:node_name]}(#{node[:error]})" }.join(", ")
@@ -151,6 +185,19 @@ module Igniter
         "Errors: #{errors.map { |error| "#{error[:node_name]}=#{error[:type]}" }.join(', ')}"
       end
 
+      def format_collection_nodes(collection_nodes)
+        return nil if collection_nodes.empty?
+
+        summaries = collection_nodes.map do |node|
+          summary = "#{node[:node_name]} total=#{node[:total]} succeeded=#{node[:succeeded]} failed=#{node[:failed]} status=#{node[:status]}"
+          next summary if node[:failed_items].empty?
+
+          "#{summary} failed_items=#{node[:failed_items].map { |item| "#{item[:key]}(#{item[:message]})" }.join(', ')}"
+        end
+
+        "Collections: #{summaries.join('; ')}"
+      end
+
       def format_events(events)
         "Events: total=#{events[:total]}, latest=#{events[:latest_type] || 'none'}"
       end
@@ -161,14 +208,43 @@ module Igniter
 
       def serialize_value(value)
         case value
+        when Runtime::DeferredResult
+          value.as_json
         when Runtime::Result
           value.to_h
+        when Runtime::CollectionResult
+          value.as_json
         when Array
           value.map { |item| serialize_value(item) }
         else
           value
         end
       end
+
+      def summarize_collection_nodes
+        execution.cache.values.filter_map do |state|
+          next unless state.value.is_a?(Runtime::CollectionResult)
+
+          result = state.value
+          {
+            node_name: state.node.name,
+            path: state.node.path,
+            mode: result.mode,
+            total: result.items.size,
+            succeeded: result.successes.size,
+            failed: result.failures.size,
+            status: result.failures.empty? ? :succeeded : :partial_failure,
+            failed_items: result.failures.values.map do |item|
+              {
+                key: item.key,
+                type: item.error.class.name,
+                message: item.error.message,
+                context: item.error.respond_to?(:context) ? item.error.context : {}
+              }
+            end
+          }
+        end
+      end
     end
   end
 end