igniter 0.5.1 → 0.5.2

data/packages/igniter-embed/lib/igniter/embed/host_builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Embed
+    class HostBuilder
+      def initialize(config:)
+        @config = config
+      end
+
+      def owner(value)
+        config.owner(value)
+      end
+
+      def path(value)
+        config.path(value)
+      end
+
+      def root(value)
+        config.root(value)
+      end
+
+      def cache(value)
+        config.cache = value
+      end
+
+      def contract(definition, as: nil)
+        config.contract(definition, as: as)
+      end
+
+      def contracts(&block)
+        config.contracts(&block)
+      end
+
+      private
+
+      attr_reader :config
+    end
+  end
+end

data/packages/igniter-embed/lib/igniter/embed/rails.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../embed"
+
+module Igniter
+  module Embed
+    module Rails
+      class << self
+        def install(container, reloader: nil, cache: nil)
+          container.config.cache = cache unless cache.nil?
+          return container unless reloader
+
+          raise RailsIntegrationError, "Rails reloader must respond to #to_prepare" unless reloader.respond_to?(:to_prepare)
+
+          reloader.to_prepare { container.reload! }
+          container
+        end
+      end
+    end
+  end
+end

data/packages/igniter-embed/lib/igniter/embed/registry.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Embed
+    class Registry
+      Registration = Struct.new(:name, :definition, :kind, keyword_init: true) do
+        def block?
+          kind == :block
+        end
+
+        def class?
+          kind == :class
+        end
+
+        def to_h
+          {
+            name: name,
+            kind: kind,
+            definition: definition_name
+          }
+        end
+
+        private
+
+        def definition_name
+          return definition.name if definition.respond_to?(:name) && definition.name
+
+          definition.inspect
+        end
+      end
+
+      def initialize
+        @contracts = {}
+      end
+
+      def register(name, definition)
+        key = normalize_name(name)
+        raise DuplicateContractError, "contract #{key} is already registered" if contracts.key?(key)
+
+        contracts[key] = Registration.new(name: key, definition: definition, kind: kind_for(definition))
+      end
+
+      def fetch(name)
+        key = normalize_name(name)
+        contracts.fetch(key)
+      rescue KeyError
+        raise UnknownContractError, "unknown contract #{key}"
+      end
+
+      def key?(name)
+        contracts.key?(normalize_name(name))
+      end
+
+      def names
+        contracts.keys
+      end
+
+      def to_h
+        contracts.transform_values(&:to_h)
+      end
+
+      private
+
+      attr_reader :contracts
+
+      def normalize_name(name)
+        name.to_sym
+      end
+
+      def kind_for(definition)
+        return :class if definition.is_a?(Class) && definition < Igniter::Contract
+        return :block if definition.respond_to?(:call)
+
+        raise ArgumentError, "contract definition must be a block or Class < Igniter::Contract"
+      end
+    end
+  end
+end

data/packages/igniter-embed/lib/igniter/embed/sugar_expansion.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Embed
+    class SugarExpansion
+      def initialize(config:)
+        @config = config
+      end
+
+      def to_h
+        {
+          host: config.name,
+          owner: owner_name,
+          root: config.root,
+          cache: config.cache?,
+          contracts: contracts,
+          contractables: contractables,
+          capabilities: [],
+          events: [],
+          clean_config: clean_config
+        }
+      end
+
+      private
+
+      attr_reader :config
+
+      def owner_name
+        owner = config.owner
+        return nil unless owner
+        return owner.name if owner.respond_to?(:name) && owner.name
+
+        owner.inspect
+      end
+
+      def contracts
+        config.contract_registrations.map do |registration|
+          {
+            name: registration_name(registration),
+            class: registration_class(registration),
+            kind: registration_kind(registration)
+          }
+        end
+      end
+
+      def clean_config
+        {
+          name: config.name,
+          owner: owner_name,
+          root: config.root,
+          cache: config.cache?,
+          contracts: contracts
+        }
+      end
+
+      def contractables
+        config.contractable_configs.map do |contractable_config|
+          {
+            name: contractable_config.name,
+            role: contractable_config.role,
+            stage: contractable_config.stage,
+            primary: callable_name(contractable_config.primary),
+            candidate: callable_name(contractable_config.candidate),
+            async: contractable_config.async,
+            sample: contractable_config.sample,
+            metadata: contractable_config.metadata,
+            adapters: adapters(contractable_config),
+            capabilities: capabilities(contractable_config),
+            events: events(contractable_config),
+            runner: runner(contractable_config)
+          }
+        end
+      end
+
+      def registration_name(registration)
+        return registration.name.to_sym if registration.name
+        return ContractNaming.infer_contract_name(registration.definition) if ContractNaming.contract_class?(registration.definition)
+
+        nil
+      end
+
+      def registration_class(registration)
+        definition = registration.definition
+        return definition.name if ContractNaming.contract_class?(definition) && definition.name
+
+        nil
+      end
+
+      def registration_kind(registration)
+        ContractNaming.contract_class?(registration.definition) ? :class : :block
+      end
+
+      def callable_name(callable)
+        return nil unless callable
+        return callable.name if callable.respond_to?(:name) && callable.name
+
+        callable.inspect
+      end
+
+      def adapters(contractable_config)
+        {
+          normalizer: normalizer_adapter(contractable_config),
+          redaction: callable_name(contractable_config.redact_inputs),
+          acceptance: acceptance_adapter(contractable_config),
+          store: callable_name(contractable_config.store)
+        }.compact
+      end
+
+      def normalizer_adapter(contractable_config)
+        primary = callable_name(contractable_config.normalize_primary)
+        candidate = callable_name(contractable_config.normalize_candidate)
+        return primary if primary == candidate
+
+        { primary: primary, candidate: candidate }.compact
+      end
+
+      def acceptance_adapter(contractable_config)
+        {
+          policy: contractable_config.accept,
+          options: contractable_config.acceptance_options
+        }
+      end
+
+      def events(contractable_config)
+        contractable_config.event_handlers.map do |event_handler|
+          {
+            event: event_handler.event,
+            source: event_handler.source,
+            handler: callable_name(event_handler.handler)
+          }
+        end
+      end
+
+      def capabilities(contractable_config)
+        contractable_config.capability_attachments.map do |attachment|
+          {
+            name: attachment.name,
+            kind: attachment.kind,
+            target: callable_name(attachment.target)
+          }
+        end
+      end
+
+      def runner(contractable_config)
+        {
+          accessor: "contractable(:#{contractable_config.name})",
+          materializable: true
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "igniter/contracts"
+require "igniter/extensions/contracts"
+
+require_relative "embed/errors"
+require_relative "embed/contract_naming"
+require_relative "embed/config"
+require_relative "embed/contracts_builder"
+require_relative "embed/sugar_expansion"
+require_relative "embed/host_builder"
+require_relative "embed/registry"
+require_relative "embed/execution_envelope"
+require_relative "embed/contract_handle"
+require_relative "embed/container"
+require_relative "embed/contractable"
+
+module Igniter
+  module Embed
+    class << self
+      def configure(name, &block)
+        config = Config.new(name: name)
+        block&.call(config)
+        Container.new(config: config)
+      end
+
+      def host(name, &block)
+        config = Config.new(name: name)
+        HostBuilder.new(config: config).instance_eval(&block) if block
+        Container.new(config: config)
+      end
+
+      def contractable(name, &block)
+        Contractable.build(name, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "igniter/embed"