igniter-contracts 0.5.2

data/lib/igniter/contracts/assembly/profile.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Igniter
+  module Contracts
+    module Assembly
+      class Profile
+        attr_reader :nodes,
+                    :dsl_keywords,
+                    :validators,
+                    :normalizers,
+                    :runtime_handlers,
+                    :diagnostics_contributors,
+                    :pack_manifests,
+                    :effects,
+                    :executors,
+                    :fingerprint
+
+        def self.build_from(kernel)
+          payload = {
+            nodes: kernel.nodes.to_h.freeze,
+            dsl_keywords: kernel.dsl_keywords.to_h.freeze,
+            validators: kernel.validators.entries.freeze,
+            normalizers: kernel.normalizers.entries.freeze,
+            runtime_handlers: kernel.runtime_handlers.to_h.freeze,
+            diagnostics_contributors: kernel.diagnostics_contributors.entries.freeze,
+            pack_manifests: kernel.pack_manifests.dup.freeze,
+            effects: kernel.effects.to_h.freeze,
+            executors: kernel.executors.to_h.freeze
+          }
+
+          new(**payload, fingerprint: fingerprint_for(payload))
+        end
+
+        def self.fingerprint_for(payload)
+          normalized = payload.map do |key, value|
+            serialized = serialize_for_fingerprint(value)
+            [key.to_s, serialized]
+          end
+
+          Digest::SHA256.hexdigest(normalized.inspect)
+        end
+
+        def self.serialize_for_fingerprint(value)
+          case value
+          when Hash
+            value.map { |entry_key, entry_value| [entry_key.to_s, entry_value.inspect] }
+          when Array
+            value.map do |entry|
+              if entry.respond_to?(:key) && entry.respond_to?(:value)
+                [entry.key.to_s, entry.value.inspect]
+              else
+                entry.inspect
+              end
+            end
+          else
+            value.inspect
+          end
+        end
+
+        def initialize(nodes:, dsl_keywords:, validators:, normalizers:, runtime_handlers:, diagnostics_contributors:,
+                       pack_manifests:, effects:, executors:, fingerprint:)
+          @nodes = nodes
+          @dsl_keywords = dsl_keywords
+          @validators = validators
+          @normalizers = normalizers
+          @runtime_handlers = runtime_handlers
+          @diagnostics_contributors = diagnostics_contributors
+          @pack_manifests = pack_manifests
+          @effects = effects
+          @executors = executors
+          @fingerprint = fingerprint
+          freeze
+        end
+
+        def node_class(kind)
+          nodes.fetch(kind.to_sym)
+        end
+
+        def dsl_keyword(name)
+          dsl_keywords.fetch(name.to_sym)
+        end
+
+        def runtime_handler(kind)
+          runtime_handlers.fetch(kind.to_sym)
+        end
+
+        def effect(name)
+          effects.fetch(name.to_sym)
+        end
+
+        def executor(name)
+          executors.fetch(name.to_sym)
+        end
+
+        def supports_node_kind?(kind)
+          nodes.key?(kind.to_sym)
+        end
+
+        def supports_effect?(name)
+          effects.key?(name.to_sym)
+        end
+
+        def supports_executor?(name)
+          executors.key?(name.to_sym)
+        end
+
+        def pack_names
+          pack_manifests.map(&:name)
+        end
+
+        def pack_manifest(name)
+          pack_manifests.find { |manifest| manifest.name == name.to_sym }
+        end
+
+        def provided_capabilities
+          pack_manifests.flat_map(&:provides_capabilities).uniq
+        end
+
+        def required_capabilities
+          pack_manifests.flat_map(&:requires_capabilities).uniq
+        end
+
+        def declared_registry_keys(registry)
+          pack_manifests
+            .flat_map { |manifest| manifest.declared_keys_for(registry) }
+            .uniq
+        end
+      end
+    end
+  end
+end

data/lib/igniter/contracts/assembly/project_pack.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Assembly
+      module ProjectPack
+        module_function
+
+        def manifest
+          PackManifest.new(
+            name: :project,
+            registry_contracts: [PackManifest.dsl_keyword(:project)]
+          )
+        end
+
+        def install_into(kernel)
+          kernel.dsl_keywords.register(:project, DslKeyword.new(:project) do |name, from:, builder:, key: nil, dig: nil, default: PathAccess::NO_DEFAULT|
+            source_name = from.to_sym
+            path = PathAccess.normalize_path(keyword_name: :project, key: key, dig: dig)
+
+            builder.add_operation(
+              kind: :compute,
+              name: name,
+              depends_on: [source_name],
+              callable: lambda do |**values|
+                source = values.fetch(source_name)
+                PathAccess.fetch_path(
+                  source,
+                  path,
+                  source_name: source_name,
+                  keyword_name: :project,
+                  default: default
+                )
+              end
+            )
+          end)
+          kernel
+        end
+      end
+    end
+  end
+end

data/lib/igniter/contracts/assembly/registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Assembly
+      class Registry
+        def initialize(name:)
+          @name = name
+          @entries = {}
+          @frozen = false
+        end
+
+        def register(key, value)
+          raise FrozenRegistryError, "#{@name} is frozen" if frozen?
+
+          normalized_key = normalize_key(key)
+          raise DuplicateRegistrationError, "#{@name} already has #{normalized_key}" if @entries.key?(normalized_key)
+
+          @entries[normalized_key] = value
+          value
+        end
+
+        def fetch(key)
+          @entries.fetch(normalize_key(key))
+        end
+
+        def registered?(key)
+          @entries.key?(normalize_key(key))
+        end
+
+        def entries
+          @entries.dup
+        end
+
+        def to_h
+          entries
+        end
+
+        def freeze!
+          @frozen = true
+          @entries.freeze
+          self
+        end
+
+        def frozen?
+          @frozen
+        end
+
+        private
+
+        def normalize_key(key)
+          key.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/igniter/contracts/assembly/step_result_pack.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Contracts
+    module Assembly
+      module StepResultPack
+        module_function
+
+        def manifest
+          PackManifest.new(
+            name: :step_result,
+            node_contracts: [PackManifest.node(:step)],
+            registry_contracts: [
+              PackManifest.validator(:step_dependencies),
+              PackManifest.validator(:step_callables),
+              PackManifest.diagnostic(:step_trace)
+            ]
+          )
+        end
+
+        def install_into(kernel)
+          kernel.nodes.register(:step, NodeType.new(kind: :step, metadata: { category: :pipeline }))
+          kernel.dsl_keywords.register(:step, step_keyword)
+          kernel.validators.register(:step_dependencies, Execution::StepResultValidators.method(:validate_step_dependencies))
+          kernel.validators.register(:step_callables, Execution::StepResultValidators.method(:validate_step_callables))
+          kernel.runtime_handlers.register(:step, Execution::StepResultRuntime.method(:handle_step))
+          kernel.diagnostics_contributors.register(:step_trace, Execution::StepResultDiagnostics)
+          kernel
+        end
+
+        def step_keyword
+          DslKeyword.new(:step, lambda { |name, builder:, **attributes, &block|
+            normalized_attributes = attributes.dup
+            normalized_attributes[:callable] = normalized_attributes.delete(:call) if normalized_attributes.key?(:call)
+            normalized_attributes[:callable] = block if block
+            builder.add_operation(kind: :step, name: name, **normalized_attributes)
+          })
+        end
+      end
+    end
+  end
+end

data/lib/igniter/contracts/assembly.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "assembly/registry"
+require_relative "assembly/ordered_registry"
+require_relative "assembly/pack"
+require_relative "assembly/pack_manifest"
+require_relative "assembly/node_type"
+require_relative "assembly/dsl_keyword"
+require_relative "assembly/path_access"
+require_relative "assembly/hook_result_policies"
+require_relative "assembly/hook_spec"
+require_relative "assembly/hook_specs"
+require_relative "assembly/profile"
+require_relative "assembly/kernel"
+require_relative "assembly/baseline_pack"
+require_relative "assembly/const_pack"
+require_relative "assembly/project_pack"
+require_relative "assembly/step_result_pack"

data/lib/igniter/contracts/contract.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Igniter
+  class Contract
+    class ResultReader
+      def initialize(outputs)
+        @outputs = outputs
+        freeze
+      end
+
+      def output(name)
+        @outputs.fetch(name.to_sym)
+      rescue KeyError
+        raise KeyError, "unknown contract output #{name}"
+      end
+
+      def to_h
+        @outputs.to_h
+      end
+
+      def method_missing(name, *args, &block)
+        return output(name) if args.empty? && block.nil? && @outputs.key?(name)
+        raise KeyError, "unknown contract output #{name}" if args.empty? && block.nil?
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @outputs.key?(name) || super
+      end
+    end
+
+    class << self
+      attr_writer :profile
+
+      def inherited(subclass)
+        super
+        subclass.profile = profile
+      end
+
+      def define(&block)
+        raise ArgumentError, "contract definition requires a block" unless block
+
+        @definition_block = block
+        @compiled_graphs = {}
+        self
+      end
+
+      def definition_block
+        @definition_block || raise(Contracts::Error, "#{name || self} does not define a contract")
+      end
+
+      def profile
+        @profile || Contracts.default_profile
+      end
+
+      def compile(profile: self.profile)
+        compiled_graphs.fetch(profile.fingerprint) do
+          compiled_graphs[profile.fingerprint] = Contracts.compile(profile: profile, &definition_block)
+        end
+      end
+
+      def call(inputs = nil, profile: self.profile, **keyword_inputs)
+        new(inputs, profile: profile, **keyword_inputs)
+      end
+
+      def execute(inputs = nil, profile: self.profile, **keyword_inputs)
+        contract = new(inputs, profile: profile, **keyword_inputs)
+        contract.execution_result
+      end
+
+      private
+
+      def compiled_graphs
+        @compiled_graphs ||= {}
+      end
+    end
+
+    attr_reader :inputs, :profile, :execution_result
+
+    def initialize(inputs = nil, profile: self.class.profile, **keyword_inputs)
+      @profile = profile
+      @inputs = normalize_inputs(inputs, keyword_inputs)
+      run!
+    end
+
+    def result
+      ResultReader.new(execution_result.outputs)
+    end
+
+    def outputs
+      execution_result.outputs
+    end
+
+    def output(name)
+      result.output(name)
+    end
+
+    def success?
+      true
+    end
+
+    def failure?
+      !success?
+    end
+
+    def update_inputs(inputs = nil, **keyword_inputs)
+      @inputs = @inputs.merge(normalize_inputs(inputs, keyword_inputs))
+      run!
+      self
+    end
+
+    def to_h
+      {
+        contract: self.class.name,
+        inputs: inputs.dup,
+        outputs: outputs.to_h,
+        success: success?
+      }
+    end
+
+    private
+
+    def run!
+      @execution_result = Contracts.execute(self.class.compile(profile: profile), inputs: inputs, profile: profile)
+    end
+
+    def normalize_inputs(inputs, keyword_inputs)
+      normalized_inputs = {}
+      normalized_inputs.merge!(inputs) if inputs
+      normalized_inputs.merge!(keyword_inputs)
+      normalized_inputs.transform_keys(&:to_sym)
+    end
+  end
+end