igniter 0.2.0 → 0.3.1

data/lib/igniter/contract.rb

@@ -7,16 +7,109 @@ 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 present(output_name, with: nil, &block)
+        raise CompileError, "present requires a block or `with:`" unless block || with
+        raise CompileError, "present cannot use both a block and `with:`" if block && with
+
+        own_output_presenters[output_name.to_sym] = with || block
+      end
+
       def compiled_graph
         @compiled_graph || superclass_compiled_graph
       end
@@ -26,8 +119,21 @@ module Igniter
         @reactions ||= []
       end
 
+      def execution_options
+        @execution_options || superclass_execution_options || {}
+      end
+
+      def output_presenters
+        inherited = superclass.respond_to?(:output_presenters) ? superclass.output_presenters : {}
+        inherited.merge(own_output_presenters)
+      end
+
       private
 
+      def own_output_presenters
+        @output_presenters ||= {}
+      end
+
       def contract_name
         name || "AnonymousContract"
       end
@@ -37,18 +143,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 +233,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 +250,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