igniter 0.5.0 → 0.5.2

data/lib/igniter/model/composition_node.rb

@@ -1,22 +0,0 @@
-# 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:, path: nil, metadata: {})
-        super(
-          id: id,
-          kind: :composition,
-          name: name,
-          path: (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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    class ComputeNode < Node
-      attr_reader :callable
-
-      def initialize(id:, name:, dependencies:, callable:, path: nil, metadata: {})
-        super(
-          id: id,
-          kind: :compute,
-          name: 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
-
-      # Seconds to cache this node's result across executions (nil = no TTL cache).
-      # Requires Igniter::NodeCache.cache to be configured.
-      def cache_ttl
-        metadata[:cache_ttl]
-      end
-
-      # When true, concurrent executions with identical dep fingerprints share one
-      # computation (the follower waits for the leader's result).
-      # Requires Igniter::NodeCache.coalescing_lock to be configured.
-      def coalesce?
-        metadata[:coalesce] == true
-      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/effect_node.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    # Represents a side-effect node in the computation graph.
-    #
-    # An EffectNode wraps an Igniter::Effect adapter class. It participates
-    # in topological ordering, dependency resolution, saga compensations,
-    # and execution reporting like any other node — but is explicitly typed
-    # as a side effect for visibility and audit purposes.
-    class EffectNode < Node
-      attr_reader :adapter_class
-
-      def initialize(id:, name:, dependencies:, adapter_class:, path: nil, metadata: {}) # rubocop:disable Metrics/ParameterLists
-        super(
-          id: id,
-          kind: :effect,
-          name: name,
-          path: path || name,
-          dependencies: dependencies,
-          metadata: metadata
-        )
-        @adapter_class = adapter_class
-      end
-
-      # @return [Symbol] e.g. :database, :http, :cache, :generic
-      def effect_type
-        adapter_class.effect_type
-      end
-
-      # @return [Boolean]
-      def idempotent?
-        adapter_class.idempotent?
-      end
-    end
-  end
-end

data/lib/igniter/model/graph.rb

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    class InputNode < Node
-      def initialize(id:, name:, path: nil, metadata: {})
-        super(id: id, kind: :input, name: name, path: (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

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    class OutputNode < Node
-      attr_reader :source
-
-      def initialize(id:, name:, source:, path: nil, metadata: {})
-        normalized_source = source.to_s
-
-        super(
-          id: id,
-          kind: :output,
-          name: name,
-          path: (path || "output.#{name}"),
-          dependencies: [normalized_source.split(".").first],
-          metadata: metadata
-        )
-        @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
-end

data/lib/igniter/model/remote_node.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    # Represents a node that executes a contract on a remote igniter-server node.
-    # The result is the outputs hash returned by the remote contract.
-    #
-    # Three routing modes:
-    #   :static     — node_url is a hard-coded URL (original behaviour)
-    #   :capability — auto-select an alive peer advertising the given capability
-    #   :pinned     — must use the specific named peer; IncidentError if down
-    class RemoteNode < Node
-      attr_reader :contract_name, :node_url, :input_mapping, :timeout, :capability, :pinned_to
-
-      def initialize(id:, name:, contract_name:, input_mapping:, # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-                     node_url: "", timeout: 30, path: nil, metadata: {}, capability: nil, pinned_to: nil)
-        super(
-          id: id,
-          kind: :remote,
-          name: name,
-          path: path || name.to_s,
-          dependencies: input_mapping.values.map(&:to_sym),
-          metadata: metadata
-        )
-        @contract_name = contract_name.to_s
-        @node_url      = node_url.to_s
-        @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
-        @timeout       = Integer(timeout)
-        @capability    = capability&.to_sym
-        @pinned_to     = pinned_to&.to_s
-      end
-
-      # Returns :static, :capability, or :pinned.
-      def routing_mode
-        return :pinned     if @pinned_to
-        return :capability if @capability
-
-        :static
-      end
-    end
-  end
-end

data/lib/igniter/model.rb

@@ -1,18 +0,0 @@
-# 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/branch_node"
-require_relative "model/collection_node"
-require_relative "model/output_node"
-require_relative "model/await_node"
-require_relative "model/remote_node"
-require_relative "model/effect_node"
-
-module Igniter
-  module Model
-  end
-end

data/lib/igniter/node_cache.rb

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module Igniter
-  # Cross-execution TTL cache and request coalescing for compute nodes.
-  #
-  # Activated per-node via the `cache_ttl:` and `coalesce:` options on `compute`:
-  #
-  #   compute :available_slots, with: [...], call: CheckAvailability,
-  #           cache_ttl: 60,     # seconds — reuse result across executions
-  #           coalesce: true     # deduplicate concurrent in-flight requests
-  #
-  # == Setup
-  #
-  #   require "igniter/node_cache"
-  #   Igniter::NodeCache.cache = Igniter::NodeCache::Memory.new
-  #   Igniter::NodeCache.coalescing_lock = Igniter::NodeCache::CoalescingLock.new
-  #
-  # Or via the configure block:
-  #
-  #   Igniter.configure do |c|
-  #     c.node_cache = Igniter::NodeCache::Memory.new
-  #     c.node_coalescing = true   # auto-creates a CoalescingLock
-  #   end
-  #
-  # == AR fingerprinting (Gap 3)
-  #
-  # Cache keys are built from a stable fingerprint of dep values.
-  # For ActiveRecord objects, include Igniter::Fingerprint (or use the Railtie):
-  #
-  #   class Trade < ApplicationRecord
-  #     include Igniter::Fingerprint
-  #     # default: "Trade:42:1712345678"
-  #   end
-  module NodeCache
-    class << self
-      # Global TTL cache backend. nil = disabled (default).
-      # Must respond to: #fetch(key) → value | nil
-      #                  #store(key, value, ttl:)
-      attr_accessor :cache
-
-      # Global coalescing lock. nil = disabled (default).
-      attr_accessor :coalescing_lock
-    end
-
-    # ─── Cache key ────────────────────────────────────────────────────────────
-
-    # Immutable key uniquely identifying a node result for a given set of dep values.
-    # Format: "ttl:{contract_name}:{node_name}:{dep_fingerprint_hex}"
-    class CacheKey
-      attr_reader :hex
-
-      def initialize(contract_name, node_name, dep_hex)
-        @hex = "ttl:#{contract_name}:#{node_name}:#{dep_hex}".freeze
-        freeze
-      end
-
-      def to_s    = @hex
-      def inspect = "#<NodeCache::CacheKey #{@hex}>"
-      def ==(other) = other.is_a?(CacheKey) && other.hex == @hex
-    end
-
-    # ─── Memory backend ───────────────────────────────────────────────────────
-
-    # Thread-safe in-process TTL store. Entries expire after their TTL.
-    # Replace with a Redis-backed implementation for multi-process sharing.
-    class Memory
-      Entry = Struct.new(:value, :expires_at) do
-        def expired? = Time.now.utc > expires_at
-      end
-
-      def initialize
-        @store  = {}
-        @mu     = Mutex.new
-        @hits   = 0
-        @misses = 0
-      end
-
-      # Returns the cached value, or nil on miss / expiry.
-      def fetch(key)
-        @mu.synchronize do
-          entry = @store[key.hex]
-          if entry.nil? || entry.expired?
-            @store.delete(key.hex) if entry
-            @misses += 1
-            nil
-          else
-            @hits += 1
-            entry.value
-          end
-        end
-      end
-
-      # Stores value with a TTL in seconds.
-      def store(key, value, ttl:)
-        @mu.synchronize do
-          @store[key.hex] = Entry.new(value, Time.now.utc + ttl)
-        end
-        value
-      end
-
-      # Remove all expired entries. Call periodically to reclaim memory.
-      def prune!
-        @mu.synchronize do
-          now = Time.now.utc
-          @store.delete_if { |_, e| e.expires_at < now }
-        end
-      end
-
-      def size  = @mu.synchronize { @store.size }
-      def clear = @mu.synchronize { @store.clear; @hits = 0; @misses = 0 }
-      def stats = @mu.synchronize { { size: @store.size, hits: @hits, misses: @misses } }
-    end
-
-    # ─── Coalescing lock ──────────────────────────────────────────────────────
-
-    # In-flight deduplication for concurrent requests with identical dep fingerprints.
-    #
-    # When two executions race to compute the same `coalesce: true` node:
-    #   • The first caller becomes the leader — computes and stores the result.
-    #   • Subsequent callers become followers — wait for the leader, then reuse its result.
-    #
-    # This eliminates duplicate work for concurrent auction-style requests
-    # (e.g. 3 vendors arriving within ~50ms for the same lead).
-    #
-    # Scope: single Ruby process. For Puma multi-worker, extend with a Redis-based
-    # implementation using SETNX advisory locks + Pub/Sub.
-    class CoalescingLock
-      WAIT_TIMEOUT = 30 # seconds before a follower gives up and computes independently
-
-      InFlight = Struct.new(:mutex, :cond, :done, :value, :error, keyword_init: true)
-
-      def initialize
-        @mu      = Mutex.new
-        @flights = {}
-      end
-
-      # Attempt to acquire a computation slot for `hex`.
-      #
-      # Returns [:leader, flight]   — caller is first; must compute then call finish!
-      # Returns [:follower, flight] — another caller is already computing; call wait(flight)
-      def acquire(hex)
-        @mu.synchronize do
-          if @flights.key?(hex)
-            [:follower, @flights[hex]]
-          else
-            flight = InFlight.new(
-              mutex: Mutex.new,
-              cond:  ConditionVariable.new,
-              done:  false,
-              value: nil,
-              error: nil
-            )
-            @flights[hex] = flight
-            [:leader, flight]
-          end
-        end
-      end
-
-      # Called by the leader when computation finishes (success or failure).
-      # Unblocks all waiting followers.
-      def finish!(hex, value: nil, error: nil)
-        flight = @mu.synchronize { @flights.delete(hex) }
-        return unless flight
-
-        flight.mutex.synchronize do
-          flight.value = value
-          flight.error = error
-          flight.done  = true
-          flight.cond.broadcast
-        end
-      end
-
-      # Called by a follower after receiving the flight object from acquire.
-      # Blocks until the leader calls finish!, then returns [value, error].
-      # Times out after WAIT_TIMEOUT seconds and returns [nil, nil] (follower recomputes).
-      def wait(flight)
-        flight.mutex.synchronize do
-          deadline = Time.now + WAIT_TIMEOUT
-          until flight.done
-            remaining = deadline - Time.now
-            break if remaining <= 0
-
-            flight.cond.wait(flight.mutex, remaining)
-          end
-          [flight.value, flight.error]
-        end
-      end
-
-      def in_flight_count = @mu.synchronize { @flights.size }
-    end
-
-    # ─── Fingerprinter ────────────────────────────────────────────────────────
-
-    # Produces a stable hex fingerprint for a set of dependency values.
-    # Used as part of the NodeCache::CacheKey.
-    #
-    # Supports the Igniter::Fingerprint protocol:
-    #   objects responding to #igniter_fingerprint return a stable string
-    #   (e.g. "Trade:42:1712345678").
-    #
-    # Fallback for unknown objects: "#ClassName@object_id" — stable within
-    # a single process but NOT across restarts. Sufficient for the in-process
-    # Memory backend; Redis-backed deployments should ensure all dep objects
-    # implement igniter_fingerprint.
-    module Fingerprinter
-      def self.call(dep_values)
-        Digest::SHA256.hexdigest(serialize(dep_values))[0..23]
-      end
-
-      def self.serialize(val) # rubocop:disable Metrics/CyclomaticComplexity
-        case val
-        when Hash
-          pairs = val.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}:#{serialize(v)}" }
-          "{#{pairs.join(",")}}"
-        when Array  then "[#{val.map { |v| serialize(v) }.join(",")}]"
-        when String then val.inspect
-        when Symbol then ":#{val}"
-        when Numeric, NilClass, TrueClass, FalseClass then val.inspect
-        else
-          if val.respond_to?(:igniter_fingerprint)
-            "fp:#{val.igniter_fingerprint}"
-          else
-            "obj:#{val.class.name}@#{val.object_id}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/igniter/property_testing/formatter.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module PropertyTesting
-    # Renders a property-test Result as a human-readable ASCII report.
-    class Formatter
-      PASS_LABEL = "PASS"
-      FAIL_LABEL = "FAIL"
-
-      def initialize(result)
-        @result = result
-      end
-
-      def render # rubocop:disable Metrics/MethodLength
-        lines = []
-        lines << header
-        lines << summary_line
-        lines << ""
-
-        if @result.passed?
-          lines << "  All #{@result.total_runs} runs passed."
-        else
-          lines << counterexample_section
-          lines << ""
-          lines << failed_runs_section
-        end
-
-        lines.join("\n")
-      end
-
-      private
-
-      def header
-        label = @result.passed? ? PASS_LABEL : FAIL_LABEL
-        "PropertyTest: #{@result.contract_class.name}  [#{label}]"
-      end
-
-      def summary_line
-        "Runs: #{@result.total_runs} | " \
-          "Passed: #{@result.passed_runs.size} | " \
-          "Failed: #{@result.failed_runs.size}"
-      end
-
-      def counterexample_section
-        cx = @result.counterexample
-        return "" unless cx
-
-        [
-          "COUNTEREXAMPLE (run ##{cx.run_number}):",
-          "  Inputs:  #{cx.inputs.inspect}",
-          "  Failure: #{cx.failure_message}"
-        ].join("\n")
-      end
-
-      def failed_runs_section
-        return "" if @result.failed_runs.empty?
-
-        lines = ["FAILED RUNS:"]
-        @result.failed_runs.each do |run|
-          lines << "  ##{run.run_number.to_s.ljust(5)} #{run.failure_message.ljust(40)} inputs: #{run.inputs.inspect}"
-        end
-        lines.join("\n")
-      end
-    end
-  end
-end