igniter 0.2.0 → 0.3.1

data/lib/igniter/diagnostics/report.rb

@@ -17,6 +17,7 @@ module Igniter
           outputs: serialize_outputs,
           errors: serialize_errors,
           nodes: summarize_nodes,
+          collection_nodes: summarize_collection_nodes,
           events: summarize_events
         }
       end
@@ -31,8 +32,9 @@ module Igniter
         lines << "Diagnostics #{report[:graph]}"
         lines << "Execution #{report[:execution_id]}"
         lines << "Status: #{report[:status]}"
-        lines << format_outputs(report[:outputs])
+        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")
@@ -45,8 +47,11 @@ module Igniter
         lines << ""
         lines << "- Execution: `#{report[:execution_id]}`"
         lines << "- Status: `#{report[:status]}`"
-        lines << "- Outputs: #{inline_hash(report[:outputs])}"
+        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?
@@ -57,6 +62,17 @@ module Igniter
           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
 
@@ -76,36 +92,52 @@ module Igniter
 
       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_result.errors.map do |node_name, error|
+        execution.cache.values.filter_map do |state|
+          next unless state.failed?
+
           {
-            node_name: node_name,
-            type: error.class.name,
-            message: error.message,
-            context: error.respond_to?(:context) ? error.context : {}
+            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)
-          memo[output_node.name] = serialize_output_state(state)
+          state = execution.cache.fetch(output_node.source_root)
+          memo[output_node.name] = serialize_output_value(output_node, state)
         end
       end
 
-      def serialize_output_state(state)
+      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
 
@@ -113,6 +145,7 @@ module Igniter
           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
@@ -137,8 +170,16 @@ module Igniter
         "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(", ")
@@ -151,24 +192,158 @@ module Igniter
         "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}=#{value.inspect}" }.join(", ")
+        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/dsl/contract_builder.rb

@@ -11,9 +11,13 @@ module Igniter
         @name = name
         @nodes = []
         @sequence = 0
+        @scope_stack = []
       end
 
       UNDEFINED_INPUT_DEFAULT = :__igniter_undefined__
+      UNDEFINED_CONST_VALUE = :__igniter_const_undefined__
+      UNDEFINED_GUARD_MATCHER = :__igniter_guard_matcher_undefined__
+      UNDEFINED_PROJECT_OPTION = :__igniter_project_undefined__
 
       def input(name, type: nil, required: nil, default: UNDEFINED_INPUT_DEFAULT, **metadata)
         input_metadata = with_source_location(metadata)
@@ -25,33 +29,141 @@ module Igniter
           Model::InputNode.new(
             id: next_id,
             name: name,
+            path: scoped_path(name),
             metadata: input_metadata
           )
         )
       end
 
-      def compute(name, depends_on:, call: nil, **metadata, &block)
-        callable = call || block
+      def compute(name, depends_on: nil, with: nil, call: nil, executor: nil, **metadata, &block)
+        callable, resolved_metadata = resolve_compute_callable(call: call, executor: executor, metadata: metadata, block: block)
         raise CompileError, "compute :#{name} requires a callable" unless callable
-        raise CompileError, "compute :#{name} cannot accept both `call:` and a block" if call && block
 
         add_node(
           Model::ComputeNode.new(
             id: next_id,
             name: name,
-            dependencies: Array(depends_on),
+            dependencies: normalize_dependencies(depends_on: depends_on, with: with),
             callable: callable,
-            metadata: with_source_location(metadata)
+            path: scoped_path(name),
+            metadata: with_source_location(resolved_metadata)
           )
         )
       end
 
+      def const(name, value = UNDEFINED_CONST_VALUE, **metadata, &block)
+        raise CompileError, "const :#{name} cannot accept both a value and a block" if !block.nil? && value != UNDEFINED_CONST_VALUE
+        raise CompileError, "const :#{name} requires a value or a block" if block.nil? && value == UNDEFINED_CONST_VALUE
+
+        callable = if block
+                     block
+                   else
+                     proc { value }
+                   end
+
+        compute(name, with: [], call: callable, **metadata.merge(kind: :const))
+      end
+
+      def lookup(name, depends_on: nil, with: nil, call: nil, executor: nil, **metadata, &block)
+        compute(name, depends_on: depends_on, with: with, call: call, executor: executor, **{ category: :lookup }.merge(metadata), &block)
+      end
+
+      def map(name, from:, call: nil, executor: nil, **metadata, &block)
+        compute(name, with: from, call: call, executor: executor, **{ category: :map }.merge(metadata), &block)
+      end
+
+      def project(name, from:, key: UNDEFINED_PROJECT_OPTION, dig: UNDEFINED_PROJECT_OPTION, default: UNDEFINED_PROJECT_OPTION, **metadata)
+        if key != UNDEFINED_PROJECT_OPTION && dig != UNDEFINED_PROJECT_OPTION
+          raise CompileError, "project :#{name} cannot use both `key:` and `dig:`"
+        end
+
+        if key == UNDEFINED_PROJECT_OPTION && dig == UNDEFINED_PROJECT_OPTION
+          raise CompileError, "project :#{name} requires either `key:` or `dig:`"
+        end
+
+        callable = proc do |**values|
+          source = values.fetch(from.to_sym)
+          extract_projected_value(
+            source,
+            key: key,
+            dig: dig,
+            default: default,
+            node_name: name
+          )
+        end
+
+        compute(name, with: from, call: callable, **{ category: :project }.merge(metadata))
+      end
+
+      def aggregate(name, depends_on: nil, with: nil, call: nil, executor: nil, **metadata, &block)
+        compute(name, depends_on: depends_on, with: with, call: call, executor: executor, **{ category: :aggregate }.merge(metadata), &block)
+      end
+
+      def guard(name, depends_on: nil, with: nil, call: nil, executor: nil, message: nil,
+                eq: UNDEFINED_GUARD_MATCHER, in: UNDEFINED_GUARD_MATCHER, matches: UNDEFINED_GUARD_MATCHER,
+                **metadata, &block)
+        matcher_options = {
+          eq: eq,
+          in: binding.local_variable_get(:in),
+          matches: matches
+        }.reject { |_key, value| value == UNDEFINED_GUARD_MATCHER }
+
+        if matcher_options.any?
+          raise CompileError, "guard :#{name} cannot combine matcher options with `call:`, `executor:`, or a block" if call || executor || block
+          raise CompileError, "guard :#{name} supports only one matcher option at a time" if matcher_options.size > 1
+
+          dependencies = normalize_dependencies(depends_on: depends_on, with: with)
+          raise CompileError, "guard :#{name} with matcher options requires exactly one dependency" unless dependencies.size == 1
+
+          dependency = dependencies.first
+          matcher_name, matcher_value = matcher_options.first
+
+          call = build_guard_matcher(matcher_name, matcher_value, dependency)
+        end
+
+        compute(
+          name,
+          depends_on: depends_on,
+          with: with,
+          call: call,
+          executor: executor,
+          **metadata.merge(kind: :guard, guard: true, guard_message: message || "Guard '#{name}' failed"),
+          &block
+        )
+      end
+
+      def export(*names, from:, **metadata)
+        names.each do |name|
+          output(name, from: "#{from}.#{name}", **metadata)
+        end
+      end
+
+      def expose(*sources, as: nil, **metadata)
+        raise CompileError, "expose cannot use `as:` with multiple sources" if as && sources.size != 1
+
+        sources.each do |source|
+          output(as || source, from: source, **metadata)
+        end
+      end
+
+      def scope(name, &block)
+        raise CompileError, "scope requires a block" unless block
+
+        @scope_stack << name.to_s
+        instance_eval(&block)
+      ensure
+        @scope_stack.pop
+      end
+
+      alias namespace scope
+
       def output(name, from: nil, **metadata)
         add_node(
           Model::OutputNode.new(
             id: next_id,
             name: name,
             source: (from || name),
+            path: scoped_output_path(name),
             metadata: with_source_location(metadata)
           )
         )
@@ -66,6 +178,51 @@ module Igniter
             name: name,
             contract_class: contract,
             input_mapping: inputs,
+            path: scoped_path(name),
+            metadata: with_source_location(metadata)
+          )
+        )
+      end
+
+      def branch(name, with:, inputs: nil, depends_on: nil, map_inputs: nil, using: nil, **metadata, &block)
+        raise CompileError, "branch :#{name} requires a block" unless block
+        raise CompileError, "branch :#{name} requires either `inputs:` or `map_inputs:`/`using:`" if inputs.nil? && map_inputs.nil? && using.nil?
+        raise CompileError, "branch :#{name} cannot combine `inputs:` with `map_inputs:` or `using:`" if inputs && (map_inputs || using)
+        raise CompileError, "branch :#{name} cannot use both `map_inputs:` and `using:`" if map_inputs && using
+        raise CompileError, "branch :#{name} requires an `inputs:` hash" if inputs && !inputs.is_a?(Hash)
+
+        definition = BranchBuilder.build(&block)
+
+        add_node(
+          Model::BranchNode.new(
+            id: next_id,
+            name: name,
+            selector_dependency: with,
+            cases: definition[:cases],
+            default_contract: definition[:default_contract],
+            input_mapping: inputs || {},
+            context_dependencies: normalize_dependencies(depends_on: depends_on, with: nil),
+            input_mapper: map_inputs || using,
+            path: scoped_path(name),
+            metadata: with_source_location(metadata)
+          )
+        )
+      end
+
+      def collection(name, with:, each:, key:, mode: :collect, depends_on: nil, map_inputs: nil, using: nil, **metadata)
+        raise CompileError, "collection :#{name} cannot use both `map_inputs:` and `using:`" if map_inputs && using
+
+        add_node(
+          Model::CollectionNode.new(
+            id: next_id,
+            name: name,
+            source_dependency: with,
+            contract_class: each,
+            key_name: key,
+            mode: mode,
+            context_dependencies: normalize_dependencies(depends_on: depends_on, with: nil),
+            input_mapper: map_inputs || using,
+            path: scoped_path(name),
             metadata: with_source_location(metadata)
           )
         )
@@ -90,6 +247,115 @@ module Igniter
       def with_source_location(metadata)
         metadata.merge(source_location: caller_locations(2, 1).first&.to_s)
       end
+
+      def resolve_compute_callable(call:, executor:, metadata:, block:)
+        raise CompileError, "compute cannot accept both `call:` and `executor:`" if call && executor
+        raise CompileError, "compute cannot accept both `call:` and a block" if call && block
+        raise CompileError, "compute cannot accept both `executor:` and a block" if executor && block
+
+        if executor
+          definition = Igniter.executor_registry.fetch(executor)
+          return [definition.executor_class, definition.metadata.merge(metadata).merge(executor_key: definition.key)]
+        end
+
+        [call || block, metadata]
+      end
+
+      def normalize_dependencies(depends_on:, with:)
+        raise CompileError, "Use either `depends_on:` or `with:`, not both" if depends_on && with
+
+        dependencies = depends_on || with
+        Array(dependencies)
+      end
+
+      def build_guard_matcher(matcher_name, matcher_value, dependency)
+        case matcher_name
+        when :eq
+          proc do |**values|
+            values.fetch(dependency) == matcher_value
+          end
+        when :in
+          allowed_values = Array(matcher_value)
+          proc do |**values|
+            allowed_values.include?(values.fetch(dependency))
+          end
+        when :matches
+          matcher = matcher_value
+          raise CompileError, "`matches:` expects a Regexp" unless matcher.is_a?(Regexp)
+
+          proc do |**values|
+            values.fetch(dependency).to_s.match?(matcher)
+          end
+        else
+          raise CompileError, "Unsupported guard matcher: #{matcher_name}"
+        end
+      end
+
+      def extract_projected_value(source, key:, dig:, default:, node_name:)
+        if key != UNDEFINED_PROJECT_OPTION
+          return fetch_project_value(source, key, default, node_name)
+        end
+
+        current = source
+        Array(dig).each do |part|
+          current = fetch_project_value(current, part, default, node_name)
+        end
+        current
+      end
+
+      def fetch_project_value(source, part, default, node_name)
+        if source.is_a?(Hash)
+          return source.fetch(part) if source.key?(part)
+          return source.fetch(part.to_s) if source.key?(part.to_s)
+          return source.fetch(part.to_sym) if source.key?(part.to_sym)
+        elsif source.respond_to?(part)
+          return source.public_send(part)
+        end
+
+        return default unless default == UNDEFINED_PROJECT_OPTION
+
+        raise ResolutionError, "project :#{node_name} could not extract #{part.inspect}"
+      end
+
+      def scoped_path(name)
+        return name.to_s if @scope_stack.empty?
+
+        "#{@scope_stack.join('.')}.#{name}"
+      end
+
+      def scoped_output_path(name)
+        return "output.#{name}" if @scope_stack.empty?
+
+        "#{@scope_stack.join('.')}.output.#{name}"
+      end
+
+      class BranchBuilder
+        def self.build(&block)
+          new.tap { |builder| builder.instance_eval(&block) }.to_h
+        end
+
+        def initialize
+          @cases = []
+          @default_contract = nil
+        end
+
+        def on(match, contract:)
+          @cases << { match: match, contract: contract }
+        end
+
+        def default(contract:)
+          raise CompileError, "branch can define only one `default`" if @default_contract
+
+          @default_contract = contract
+        end
+
+        def to_h
+          {
+            cases: @cases,
+            default_contract: @default_contract
+          }
+        end
+      end
     end
   end
 end

data/lib/igniter/dsl/schema_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Igniter
+  module DSL
+    class SchemaBuilder
+      def self.compile(schema, name: nil)
+        new(schema, name: name).compile
+      end
+
+      def initialize(schema, name: nil)
+        @schema = symbolize(schema)
+        @name = name || @schema[:name] || "AnonymousContract"
+      end
+
+      def compile
+        schema = @schema
+
+        ContractBuilder.compile(name: @name) do
+          Array(schema[:inputs]).each do |input_config|
+            config = input_config
+            input(
+              config.fetch(:name),
+              type: config[:type],
+              required: config[:required],
+              default: config.fetch(:default, ContractBuilder::UNDEFINED_INPUT_DEFAULT),
+              **config.fetch(:metadata, {})
+            )
+          end
+
+          Array(schema[:compositions]).each do |composition_config|
+            config = composition_config
+            compose(
+              config.fetch(:name),
+              contract: config.fetch(:contract),
+              inputs: config.fetch(:inputs),
+              **config.fetch(:metadata, {})
+            )
+          end
+
+          Array(schema[:computes]).each do |compute_config|
+            config = compute_config
+            options = {
+              depends_on: Array(config.fetch(:depends_on)).map(&:to_sym)
+            }
+            options[:call] = config[:call] if config.key?(:call)
+            options[:executor] = config[:executor] if config.key?(:executor)
+            compute(config.fetch(:name), **options, **config.fetch(:metadata, {}))
+          end
+
+          Array(schema[:outputs]).each do |output_config|
+            config = output_config
+            output(config.fetch(:name), from: config[:from], **config.fetch(:metadata, {}))
+          end
+        end
+      end
+
+      private
+
+      def symbolize(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, nested), memo|
+            memo[key.to_sym] = symbolize(nested)
+          end
+        when Array
+          value.map { |item| symbolize(item) }
+        else
+          value
+        end
+      end
+    end
+  end
+end