igniter 0.5.0 → 0.5.2

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

@@ -1,80 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,349 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Diagnostics
-    class Report
-      def initialize(execution)
-        @execution = execution
-      end
-
-      def to_h
-        safely_resolve_execution
-
-        {
-          graph: execution.compiled_graph.name,
-          execution_id: execution.events.execution_id,
-          status: status,
-          outputs: serialize_outputs,
-          errors: serialize_errors,
-          nodes: summarize_nodes,
-          collection_nodes: summarize_collection_nodes,
-          events: summarize_events
-        }
-      end
-
-      def as_json(*)
-        to_h
-      end
-
-      def to_text
-        report = to_h
-        lines = []
-        lines << "Diagnostics #{report[:graph]}"
-        lines << "Execution #{report[:execution_id]}"
-        lines << "Status: #{report[:status]}"
-        lines << format_outputs(presented_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")
-      end
-
-      def to_markdown
-        report = to_h
-        lines = []
-        lines << "# Diagnostics #{report[:graph]}"
-        lines << ""
-        lines << "- Execution: `#{report[:execution_id]}`"
-        lines << "- Status: `#{report[:status]}`"
-        lines << "- Outputs: #{inline_hash(presented_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?
-          lines << ""
-          lines << "## Errors"
-          report[:errors].each do |error|
-            lines << "- `#{error[:node_name]}`: #{error[:message]}"
-          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
-
-      private
-
-      attr_reader :execution
-
-      def execution_result
-        @execution_result ||= Runtime::Result.new(execution)
-      end
-
-      def safely_resolve_execution
-        execution.resolve_all
-      rescue Igniter::Error
-        nil
-      end
-
-      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.cache.values.filter_map do |state|
-          next unless state.failed?
-
-          {
-            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_root)
-          memo[output_node.name] = serialize_output_value(output_node, state)
-        end
-      end
-
-      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
-
-        {
-          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
-
-            { node_name: node_name, path: state[:path], error: state[:error] }
-          end
-        }
-      end
-
-      def summarize_events
-        events = execution.events.events
-
-        {
-          total: events.size,
-          latest_type: events.last&.type,
-          latest_at: events.last&.timestamp,
-          by_type: events.each_with_object(Hash.new(0)) { |event, memo| memo[event.type] += 1 }
-        }
-      end
-
-      def format_outputs(outputs)
-        "Outputs: #{inline_hash(outputs)}"
-      end
-
-      def presented_outputs
-        @presented_outputs ||= execution.compiled_graph.outputs.each_with_object({}) do |output_node, memo|
-          raw_value = to_h[:outputs][output_node.name]
-          memo[output_node.name] = present_output(output_node.name, raw_value)
-        end
-      end
-
-      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(", ")
-        "#{line}\nFailed Nodes: #{failures}"
-      end
-
-      def format_errors(errors)
-        return "Errors: none" if errors.empty?
-
-        "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
-
-      def inline_hash(hash)
-        hash.map { |key, value| "#{key}=#{inline_value(value)}" }.join(", ")
-      end
-
-      def present_output(output_name, raw_value)
-        presenter = execution.contract_instance.class.output_presenters[output_name.to_sym]
-        return raw_value unless presenter
-
-        if presenter.is_a?(Symbol) || presenter.is_a?(String)
-          execution.contract_instance.public_send(
-            presenter,
-            value: raw_value,
-            contract: execution.contract_instance,
-            execution: execution
-          )
-        else
-          presenter.call(
-            value: raw_value,
-            contract: execution.contract_instance,
-            execution: execution
-          )
-        end
-      end
-
-      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 inline_value(value)
-        case value
-        when Hash
-          return summarize_serialized_collection_hash(value) if serialized_collection_hash?(value)
-          return summarize_serialized_collection_items_hash(value) if serialized_collection_items_hash?(value)
-
-          "{#{value.map { |key, nested| "#{key}: #{inline_value(nested)}" }.join(', ')}}"
-        when Array
-          "[#{value.map { |item| inline_value(item) }.join(', ')}]"
-        when Runtime::Result
-          summarize_nested_result(value)
-        when Runtime::CollectionResult
-          summarize_collection_result(value)
-        else
-          value.inspect
-        end
-      end
-
-      def summarize_nested_result(result)
-        outputs = result.to_h.keys
-        "{graph=#{result.execution.compiled_graph.name.inspect}, status=#{nested_result_status(result).inspect}, outputs=#{outputs.inspect}}"
-      end
-
-      def summarize_collection_result(result)
-        summary = result.summary
-        failed_keys = result.failures.keys
-        "{mode=#{result.mode.inspect}, total=#{summary[:total]}, succeeded=#{summary[:succeeded]}, failed=#{summary[:failed]}, status=#{summary[:status].inspect}, keys=#{result.keys.inspect}, failed_keys=#{failed_keys.inspect}}"
-      end
-
-      def serialized_collection_hash?(value)
-        value.key?(:mode) && value.key?(:summary) && value.key?(:items)
-      end
-
-      def summarize_serialized_collection_hash(value)
-        summary = value[:summary] || {}
-        items = value[:items] || {}
-        failed_keys = items.each_with_object([]) do |(key, item), memo|
-          memo << key if item[:status] == :failed || item["status"] == :failed
-        end
-
-        "{mode=#{value[:mode].inspect}, total=#{summary[:total]}, succeeded=#{summary[:succeeded]}, failed=#{summary[:failed]}, status=#{summary[:status].inspect}, keys=#{items.keys.inspect}, failed_keys=#{failed_keys.inspect}}"
-      end
-
-      def serialized_collection_items_hash?(value)
-        return false if value.empty?
-
-        value.values.all? do |item|
-          item.is_a?(Hash) && (item.key?(:key) || item.key?("key")) && (item.key?(:status) || item.key?("status"))
-        end
-      end
-
-      def summarize_serialized_collection_items_hash(value)
-        failed_keys = value.each_with_object([]) do |(key, item), memo|
-          status = item[:status] || item["status"]
-          memo << key if status == :failed || status == "failed"
-        end
-
-        total = value.size
-        failed = failed_keys.size
-        succeeded = total - failed
-        status = failed.zero? ? :succeeded : :partial_failure
-
-        "{mode=:collect, total=#{total}, succeeded=#{succeeded}, failed=#{failed}, status=#{status.inspect}, keys=#{value.keys.inspect}, failed_keys=#{failed_keys.inspect}}"
-      end
-
-      def nested_result_status(result)
-        return :failed if result.failed?
-        return :pending if result.pending?
-
-        :succeeded
-      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

data/lib/igniter/diagnostics.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "diagnostics/report"
-
-module Igniter
-  module Diagnostics
-  end
-end

data/lib/igniter/differential/divergence.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Differential
-    # Captures a single output that differed between primary and candidate.
-    class Divergence
-      attr_reader :output_name, :primary_value, :candidate_value, :kind
-
-      # @param output_name [Symbol]
-      # @param primary_value [Object]
-      # @param candidate_value [Object]
-      # @param kind [Symbol] :value_mismatch | :type_mismatch
-      def initialize(output_name:, primary_value:, candidate_value:, kind:)
-        @output_name = output_name
-        @primary_value = primary_value
-        @candidate_value = candidate_value
-        @kind = kind
-        freeze
-      end
-
-      # Numeric difference (candidate − primary). nil for non-numeric values.
-      def delta
-        return nil unless primary_value.is_a?(Numeric) && candidate_value.is_a?(Numeric)
-
-        candidate_value - primary_value
-      end
-    end
-  end
-end

data/lib/igniter/differential/formatter.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Differential
-    # Renders a Differential::Report as a human-readable text block.
-    #
-    # Example:
-    #
-    #   Primary:    PricingV1
-    #   Candidate:  PricingV2
-    #   Match:      NO
-    #
-    #   DIVERGENCES (1):
-    #     :tax
-    #       primary:   15.0
-    #       candidate: 22.5
-    #       delta:     +7.5
-    #
-    #   CANDIDATE ONLY (1):
-    #     :discount = 10.0
-    #
-    module Formatter
-      VALUE_MAX = 60
-
-      class << self
-        def format(report) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          lines = []
-          lines << "Primary:    #{report.primary_class.name}"
-          lines << "Candidate:  #{report.candidate_class.name}"
-          lines << "Match:      #{report.match? ? "YES" : "NO"}"
-
-          if report.primary_error
-            lines << ""
-            lines << "PRIMARY ERROR: #{report.primary_error.message}"
-            return lines.join("\n")
-          end
-
-          if report.candidate_error
-            lines << ""
-            lines << "CANDIDATE ERROR: #{report.candidate_error.message}"
-          end
-
-          lines << ""
-
-          if report.divergences.empty? && report.primary_only.empty? && report.candidate_only.empty?
-            lines << "All shared outputs match."
-          else
-            append_divergences(report, lines)
-            append_only_section("CANDIDATE ONLY", report.candidate_only, lines)
-            append_only_section("PRIMARY ONLY", report.primary_only, lines)
-          end
-
-          lines.join("\n")
-        end
-
-        private
-
-        def append_divergences(report, lines) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          return if report.divergences.empty?
-
-          lines << "DIVERGENCES (#{report.divergences.size}):"
-          report.divergences.each do |div|
-            lines << "  :#{div.output_name}"
-            lines << "    primary:   #{fmt(div.primary_value)}"
-            lines << "    candidate: #{fmt(div.candidate_value)}"
-            next unless div.delta
-
-            d = div.delta
-            lines << "    delta:     #{d >= 0 ? "+#{d}" : d}"
-          end
-          lines << ""
-        end
-
-        def append_only_section(label, hash, lines)
-          return if hash.empty?
-
-          lines << "#{label} (#{hash.size}):"
-          hash.each { |name, val| lines << "  :#{name} = #{fmt(val)}" }
-          lines << ""
-        end
-
-        def fmt(value) # rubocop:disable Metrics/CyclomaticComplexity
-          str = case value
-                when nil    then "nil"
-                when String then value.inspect
-                when Symbol then value.inspect
-                when Hash   then "{#{value.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
-                when Array  then "[#{value.map(&:inspect).join(", ")}]"
-                else             value.inspect
-                end
-          str.length > VALUE_MAX ? "#{str[0, VALUE_MAX - 3]}..." : str
-        end
-      end
-    end
-  end
-end