igniter 0.5.1 → 0.5.2

data/packages/igniter-contracts/lib/igniter/contracts/execution/structured_dump.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Execution
+      module StructuredDump
+        module_function
+
+        def dump(value)
+          case value
+          when Array
+            value.map { |entry| dump(entry) }
+          when Hash
+            value.to_h { |key, entry| [normalize_key(key), dump(entry)] }
+          else
+            dump_object(value)
+          end
+        end
+
+        def dump_object(value)
+          if serializable_contract_object?(value)
+            value.to_h
+          else
+            value
+          end
+        end
+
+        def serializable_contract_object?(value)
+          value.is_a?(NamedValues) ||
+            value.is_a?(Operation) ||
+            value.is_a?(CompiledGraph) ||
+            value.is_a?(ExecutionResult) ||
+            value.is_a?(EffectInvocation) ||
+            value.is_a?(ExecutionRequest) ||
+            value.is_a?(DiagnosticsSection) ||
+            value.is_a?(DiagnosticsReport) ||
+            value.is_a?(ValidationFinding) ||
+            value.is_a?(ValidationReport) ||
+            value.is_a?(CompilationReport) ||
+            (defined?(StepResult) && value.is_a?(StepResult))
+        end
+
+        def normalize_key(key)
+          key.respond_to?(:to_sym) ? key.to_sym : key
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/contracts/execution/validation_finding.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Execution
+      class ValidationFinding
+        attr_reader :code, :message, :subjects, :metadata
+
+        def initialize(code:, message:, subjects: [], metadata: {})
+          @code = code.to_sym
+          @message = message
+          @subjects = Array(subjects).map(&:to_sym).freeze
+          @metadata = metadata.freeze
+          freeze
+        end
+
+        def to_h
+          {
+            code: code,
+            message: message,
+            subjects: subjects,
+            metadata: StructuredDump.dump(metadata)
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/contracts/execution/validation_report.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Execution
+      class ValidationReport
+        attr_reader :operations, :findings, :profile_fingerprint
+
+        def initialize(operations:, findings:, profile_fingerprint:)
+          @operations = operations.freeze
+          @findings = findings.freeze
+          @profile_fingerprint = profile_fingerprint
+          freeze
+        end
+
+        def ok?
+          findings.empty?
+        end
+
+        def invalid?
+          !ok?
+        end
+
+        def raise_if_invalid!
+          return self if ok?
+
+          raise ValidationError.new(findings: findings)
+        end
+
+        def to_compiled_graph
+          raise_if_invalid!
+          CompiledGraph.new(operations: operations, profile_fingerprint: profile_fingerprint)
+        end
+
+        def to_h
+          {
+            operations: StructuredDump.dump(operations),
+            findings: StructuredDump.dump(findings),
+            profile_fingerprint: profile_fingerprint,
+            ok: ok?
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/contracts/execution.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "execution/baseline_normalizers"
+require_relative "execution/baseline_validators"
+require_relative "execution/baseline_runtime"
+require_relative "execution/const_runtime"
+require_relative "execution/inline_executor"
+require_relative "execution/operation"
+require_relative "execution/named_values"
+require_relative "execution/mutable_named_values"
+require_relative "execution/effect_invocation"
+require_relative "execution/execution_request"
+require_relative "execution/diagnostics_section"
+require_relative "execution/validation_finding"
+require_relative "execution/validation_report"
+require_relative "execution/compilation_report"
+require_relative "execution/structured_dump"
+require_relative "execution/step_result"
+require_relative "execution/step_result_runtime"
+require_relative "execution/step_result_validators"
+require_relative "execution/step_result_diagnostics"
+require_relative "execution/compiled_graph"
+require_relative "execution/builder"
+require_relative "execution/compiler"
+require_relative "execution/execution_result"
+require_relative "execution/runtime"
+require_relative "execution/diagnostics_report"
+require_relative "execution/diagnostics"

data/packages/igniter-contracts/lib/igniter/contracts.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "contracts/errors"
+require_relative "contracts/environment"
+require_relative "contracts/assembly"
+require_relative "contracts/execution"
+require_relative "contracts/contractable"
+require_relative "contracts/contract"
+
+module Igniter
+  module Contracts
+    Registry = Assembly::Registry
+    OrderedRegistry = Assembly::OrderedRegistry
+    Pack = Assembly::Pack
+    PackManifest = Assembly::PackManifest
+    NodeType = Assembly::NodeType
+    DslKeyword = Assembly::DslKeyword
+    HookResultPolicies = Assembly::HookResultPolicies
+    HookSpec = Assembly::HookSpec
+    HookSpecs = Assembly::HookSpecs
+    Profile = Assembly::Profile
+    Kernel = Assembly::Kernel
+    PathAccess = Assembly::PathAccess
+    BaselinePack = Assembly::BaselinePack
+    ConstPack = Assembly::ConstPack
+    ProjectPack = Assembly::ProjectPack
+    StepResultPack = Assembly::StepResultPack
+
+    CompiledGraph = Execution::CompiledGraph
+    Builder = Execution::Builder
+    Compiler = Execution::Compiler
+    ExecutionResult = Execution::ExecutionResult
+    Runtime = Execution::Runtime
+    DiagnosticsReport = Execution::DiagnosticsReport
+    Diagnostics = Execution::Diagnostics
+    BaselineNormalizers = Execution::BaselineNormalizers
+    BaselineValidators = Execution::BaselineValidators
+    BaselineRuntime = Execution::BaselineRuntime
+    ConstRuntime = Execution::ConstRuntime
+    InlineExecutor = Execution::InlineExecutor
+    Operation = Execution::Operation
+    NamedValues = Execution::NamedValues
+    EffectInvocation = Execution::EffectInvocation
+    ExecutionRequest = Execution::ExecutionRequest
+    DiagnosticsSection = Execution::DiagnosticsSection
+    ValidationFinding = Execution::ValidationFinding
+    ValidationReport = Execution::ValidationReport
+    CompilationReport = Execution::CompilationReport
+    MutableNamedValues = Execution::MutableNamedValues
+    StepResult = Execution::StepResult
+  end
+end
+
+require_relative "contracts/api"

data/packages/igniter-contracts/lib/igniter/lang/backend.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Lang
+    module Backend
+      def compile(...)
+        raise NotImplementedError, "#{self.class} must implement #compile"
+      end
+
+      def execute(...)
+        raise NotImplementedError, "#{self.class} must implement #execute"
+      end
+
+      def verify(...)
+        raise NotImplementedError, "#{self.class} must implement #verify"
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/lang/backends/ruby.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Lang
+    module Backends
+      class Ruby
+        include Backend
+
+        attr_reader :profile
+
+        def initialize(profile: Igniter::Contracts.default_profile)
+          @profile = profile
+        end
+
+        def compile(profile: self.profile, &block)
+          Igniter::Contracts.compile(profile: profile, &block)
+        end
+
+        def compilation_report(profile: self.profile, &block)
+          Igniter::Contracts.compilation_report(profile: profile, &block)
+        end
+
+        def execute(artifact, inputs:, profile: self.profile)
+          Igniter::Contracts.execute(artifact, inputs: inputs, profile: profile)
+        end
+
+        def diagnose(result, profile: self.profile)
+          Igniter::Contracts.diagnose(result, profile: profile)
+        end
+
+        def verify(artifact = nil, profile: self.profile, &block)
+          if block
+            report = compilation_report(profile: profile, &block)
+            return VerificationReport.from_compilation_report(report)
+          end
+
+          VerificationReport.from_artifact(artifact, profile_fingerprint: profile.fingerprint)
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/lang/diagnostic_payload.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Lang
+    class DiagnosticPayload
+      SEMANTICS = {
+        report_only: true,
+        runtime_enforced: false,
+        package_adapter_authorized: false,
+        real_data_export_authorized: false,
+        readiness_enforced: false,
+        ledger_core: false
+      }.freeze
+
+      DEFAULT_REDACTION_POLICY = {
+        raw_ref_export: false,
+        hash_source_refs: true,
+        redacted_ref_kinds: []
+      }.freeze
+
+      STATUSES = %i[ok warning blocked unknown].freeze
+      DECISIONS = %i[trusted provisional blocked unknown].freeze
+      RAW_REF_KEYS = %i[raw_ref raw_refs raw_source_ref raw_source_refs].freeze
+      RAW_REF_PREFIX = "raw:"
+
+      attr_reader :diagnostic_id,
+                  :profile,
+                  :status,
+                  :decision,
+                  :payload,
+                  :evidence_links,
+                  :redaction_policy,
+                  :metadata
+
+      def initialize(
+        diagnostic_id:,
+        profile:,
+        status:,
+        decision:,
+        payload: {},
+        evidence_links: {},
+        redaction_policy: {},
+        metadata: {}
+      )
+        @diagnostic_id = require_value(:diagnostic_id, diagnostic_id)
+        @profile = require_value(:profile, profile)
+        @status = normalize_status(status)
+        @decision = normalize_decision(decision)
+        @payload = deep_freeze(normalize_hash(payload, :payload))
+        @evidence_links = deep_freeze(normalize_hash(evidence_links, :evidence_links))
+        @redaction_policy = deep_freeze(normalize_redaction_policy(redaction_policy))
+        @metadata = deep_freeze(normalize_hash(metadata, :metadata))
+        reject_raw_refs!
+        freeze
+      end
+
+      def report_only?
+        true
+      end
+
+      def runtime_enforced?
+        false
+      end
+
+      def to_h
+        {
+          diagnostic_id: diagnostic_id,
+          profile: profile,
+          status: status,
+          decision: decision,
+          payload: payload,
+          evidence_links: evidence_links,
+          redaction_policy: redaction_policy,
+          semantics: SEMANTICS,
+          metadata: metadata
+        }
+      end
+
+      private
+
+      def require_value(name, value)
+        raise ArgumentError, "#{name} is required" if value.nil?
+
+        value
+      end
+
+      def normalize_status(value)
+        status_value = require_value(:status, value).to_sym
+        return status_value if STATUSES.include?(status_value)
+
+        raise ArgumentError, "status must be one of #{STATUSES.join(", ")}"
+      end
+
+      def normalize_decision(value)
+        decision_value = require_value(:decision, value).to_sym
+        return decision_value if DECISIONS.include?(decision_value)
+
+        raise ArgumentError, "decision must be one of #{DECISIONS.join(", ")}"
+      end
+
+      def normalize_redaction_policy(value)
+        policy = DEFAULT_REDACTION_POLICY.merge(normalize_hash(value, :redaction_policy))
+        raise ArgumentError, "redaction_policy.raw_ref_export must be true or false" unless [true, false].include?(policy[:raw_ref_export])
+
+        raise ArgumentError, "redaction_policy.raw_ref_export true is not supported in v0" if policy[:raw_ref_export]
+
+        policy[:redacted_ref_kinds] = Array(policy[:redacted_ref_kinds]).map(&:to_s)
+        policy
+      end
+
+      def reject_raw_refs!
+        raw_path = find_raw_ref(
+          payload: payload,
+          evidence_links: evidence_links,
+          metadata: metadata
+        )
+        raise ArgumentError, "raw refs are not allowed in diagnostic payloads at #{raw_path}" if raw_path
+      end
+
+      def find_raw_ref(value, path = [])
+        case value
+        when Hash
+          value.each do |key, entry|
+            normalized_key = key.respond_to?(:to_sym) ? key.to_sym : key
+            return (path + [normalized_key]).join(".") if RAW_REF_KEYS.include?(normalized_key)
+
+            nested = find_raw_ref(entry, path + [normalized_key])
+            return nested if nested
+          end
+        when Array
+          value.each_with_index do |entry, index|
+            nested = find_raw_ref(entry, path + [index])
+            return nested if nested
+          end
+        when String
+          return path.join(".") if value.start_with?(RAW_REF_PREFIX)
+        end
+
+        nil
+      end
+
+      def normalize_hash(value, name)
+        raise ArgumentError, "#{name} must be a hash" unless value.respond_to?(:to_h)
+
+        value.to_h.each_with_object({}) do |(key, entry), hash|
+          normalized_key = key.respond_to?(:to_sym) ? key.to_sym : key
+          hash[normalized_key] = normalize_value(entry)
+        end
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash
+          normalize_hash(value, :value)
+        when Array
+          value.map { |entry| normalize_value(entry) }
+        else
+          value
+        end
+      end
+
+      def deep_freeze(value)
+        case value
+        when Array
+          value.map { |entry| deep_freeze(entry) }.freeze
+        when Hash
+          value.transform_values { |entry| deep_freeze(entry) }.freeze
+        else
+          value.freeze
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/lang/metadata_carrier_manifest.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Lang
+    class MetadataCarrierManifest
+      KNOWN_SECTIONS = %i[
+        diagnostics
+        receipts
+        model_validity_reports
+        scenario_comparison_reports
+        review_receipts
+      ].freeze
+
+      CUSTOM_SECTIONS_KEY = :custom_sections
+
+      ENTRY_SEMANTICS = {
+        report_only: true,
+        runtime_enforced: false,
+        raw_ref_export: false
+      }.freeze
+
+      attr_reader :sections
+
+      def self.from_metadata(metadata)
+        new(sections: build_sections(metadata))
+      end
+
+      def initialize(sections: [])
+        @sections = sections.map { |entry| deep_freeze(entry) }.freeze
+        freeze
+      end
+
+      def empty?
+        sections.empty?
+      end
+
+      def to_h
+        {
+          sections: sections
+        }
+      end
+
+      class << self
+        private
+
+        def build_sections(metadata)
+          metadata_hash = metadata.to_h
+          known_sections = KNOWN_SECTIONS.filter_map do |section_name|
+            next unless metadata_hash.key?(section_name)
+
+            build_section(section_name, metadata_hash.fetch(section_name), custom: false)
+          end
+
+          custom_sections = build_custom_sections(metadata_hash.fetch(CUSTOM_SECTIONS_KEY, {}))
+          known_sections + custom_sections
+        end
+
+        def build_custom_sections(value)
+          return [] if value.nil? || value == {}
+          raise ArgumentError, "metadata.custom_sections must be a hash" unless value.is_a?(Hash)
+
+          value.to_h.map do |section_name, entries|
+            normalized_name = section_name.respond_to?(:to_sym) ? section_name.to_sym : section_name
+            raise ArgumentError, "metadata.custom_sections.#{normalized_name} duplicates a known section" if KNOWN_SECTIONS.include?(normalized_name)
+
+            build_section(normalized_name, entries, custom: true)
+          end
+        end
+
+        def build_section(section_name, value, custom:)
+          entries = normalize_section_entries(section_name, value)
+          {
+            section_name: section_name,
+            count: entries.length,
+            profile_names: profile_names(entries),
+            custom: custom
+          }.merge(ENTRY_SEMANTICS)
+        end
+
+        def normalize_section_entries(section_name, value)
+          raise ArgumentError, "metadata.#{section_name} must be an array of hashes" unless value.is_a?(Array)
+
+          value.each_with_index.map do |entry, index|
+            raise ArgumentError, "metadata.#{section_name}[#{index}] must be a hash" unless entry.respond_to?(:to_h)
+
+            entry.to_h
+          end
+        end
+
+        def profile_names(entries)
+          entries.filter_map do |entry|
+            profile = entry[:profile] || entry["profile"] || entry[:profile_name] || entry["profile_name"]
+            profile.to_s unless profile.nil?
+          end.uniq.freeze
+        end
+      end
+
+      private
+
+      def deep_freeze(value)
+        case value
+        when Array
+          value.map { |entry| deep_freeze(entry) }.freeze
+        when Hash
+          value.transform_values { |entry| deep_freeze(entry) }.freeze
+        else
+          value.freeze
+        end
+      end
+    end
+  end
+end

data/packages/igniter-contracts/lib/igniter/lang/metadata_manifest.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Lang
+    class MetadataManifest
+      SEMANTICS = {
+        report_only: true,
+        runtime_enforced: false
+      }.freeze
+
+      attr_reader :descriptors, :return_types, :budgets
+
+      def self.from_operations(operations)
+        new(
+          descriptors: extract_descriptors(operations),
+          return_types: extract_return_types(operations),
+          budgets: extract_budgets(operations)
+        )
+      end
+
+      def initialize(descriptors: [], return_types: [], budgets: [])
+        @descriptors = freeze_entries(descriptors)
+        @return_types = freeze_entries(return_types)
+        @budgets = freeze_entries(budgets)
+        freeze
+      end
+
+      def report_only?
+        true
+      end
+
+      def runtime_enforced?
+        false
+      end
+
+      def to_h
+        {
+          descriptors: descriptors,
+          return_types: return_types,
+          budgets: budgets,
+          stores: [],
+          invariants: [],
+          semantics: SEMANTICS
+        }
+      end
+
+      class << self
+        private
+
+        def extract_descriptors(operations)
+          operations.filter_map do |operation|
+            type = operation.attributes[:type]
+            next unless type.is_a?(Types::Descriptor)
+
+            {
+              node: operation.name,
+              kind: operation.kind,
+              type: serialize_value(type),
+              enforced: false
+            }
+          end
+        end
+
+        def extract_return_types(operations)
+          operations.filter_map do |operation|
+            next unless operation.attribute?(:return_type)
+
+            {
+              node: operation.name,
+              kind: operation.kind,
+              return_type: serialize_value(operation.attributes[:return_type]),
+              enforced: false
+            }
+          end
+        end
+
+        def extract_budgets(operations)
+          operations.filter_map do |operation|
+            deadline = operation.attributes[:deadline]
+            wcet = operation.attributes[:wcet]
+            next unless deadline || wcet
+
+            entry = {
+              node: operation.name,
+              kind: operation.kind,
+              enforced: false
+            }
+            entry[:deadline] = serialize_value(deadline) if deadline
+            entry[:wcet] = serialize_value(wcet) if wcet
+            entry
+          end
+        end
+
+        def serialize_value(value)
+          case value
+          when Types::Descriptor
+            value.to_h
+          when Module
+            value.name
+          when Array
+            value.map { |entry| serialize_value(entry) }
+          when Hash
+            value.to_h { |key, entry| [key.respond_to?(:to_sym) ? key.to_sym : key, serialize_value(entry)] }
+          else
+            value.respond_to?(:to_h) && !value.is_a?(Numeric) ? value.to_h : value
+          end
+        end
+      end
+
+      private
+
+      def freeze_entries(entries)
+        entries.map { |entry| deep_freeze(entry) }.freeze
+      end
+
+      def deep_freeze(value)
+        case value
+        when Array
+          value.map { |entry| deep_freeze(entry) }.freeze
+        when Hash
+          value.transform_values { |entry| deep_freeze(entry) }.freeze
+        else
+          value.freeze
+        end
+      end
+    end
+  end
+end