igniter 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cac7a900895eb96dbf1b12c619e8ff0ea0cb54557b8d605694710984b4baa37
-  data.tar.gz: 16b610374e8bbfaedeae1e01b57878e52ff2399ff4a566a62ff5926203ece4c5
+  metadata.gz: 659dfe833fdf98b7d1b446e08d02464545fd0fe9b61badd5cf8e7ca73beb6a1b
+  data.tar.gz: 5af168ce8c6fad1c18dd0d9703281ea64062c3a6d3e954b12172f29210e12c5b
 SHA512:
-  metadata.gz: 28cddf140914921cf31d05255122aeebcb892f5cae91daf27eb37ec4433be7e96b640a9c82175ef4e2995085cd036762d38963d275e4916b1ecbc5f9225cf18c
-  data.tar.gz: 2fbea23399d3d17d453ea83b9bf747a3a73d45eeb3cf01546d6e73e64c9354808414c7821c6dab28b070133a11d31440108aca3fe63a5a4ee0838407b207732c
+  metadata.gz: 5865bc3fb30c137baa5bdf87b63f9023c95c50afa87701a052a47726d139ab6113ed52820f629d0b45de421247778d560133e2c2d2f5e756681a14af2cac0026
+  data.tar.gz: de8fa4b7f92a566016f21d81acdbf9d5ec4f4f0fa458ac99b18f8c5cced124390276ea541a1f252067009fd4e3ccf688d97d239080b8995227fc697f0d5b9e6e

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.3.1] - 2026-03-19
+
+- Add DX-oriented DSL helpers `project` and `aggregate` for compact extraction and summary nodes.
+- Extend `branch` and `collection` with `map_inputs:` and named `using:` mappers to reduce orchestration wiring noise.
+- Allow `collection` mapper mode to iterate over hash-like sources directly without a preparatory `to_a` node.
+- Add diagnostics-only output presenters via `present` for compact human-facing summaries without changing raw machine-readable outputs.
+- Improve diagnostics formatting for nested branch/collection outputs and clean up inline value rendering for hashes and symbol-heavy summaries.
+- Validate and exercise the new DX surface against private production-like scheduler migration POCs.
+
 ## [0.3.0] - 2026-03-19
 
 - Add executor metadata and global executor registry for self-describing, schema-friendly execution steps.

data/README.md

@@ -9,7 +9,7 @@ Igniter is a Ruby gem for expressing business logic as a validated dependency gr
 - runtime auditing
 - diagnostics reports
 - reactive side effects
-- ergonomic DSL helpers (`with`, `const`, `lookup`, `map`, `guard`, `export`, `expose`, `effect`, `on_success`, `scope`, `namespace`, `branch`, `collection`)
+- ergonomic DSL helpers (`with`, `const`, `lookup`, `map`, `project`, `aggregate`, `guard`, `export`, `expose`, `effect`, `on_success`, `scope`, `namespace`, `branch`, `collection`)
 - graph and runtime introspection
 - async-capable pending nodes with snapshot/restore
 - store-backed execution resume flows
@@ -87,7 +87,7 @@ There is also a short patterns guide in [`docs/PATTERNS.md`](docs/PATTERNS.md).
 | `marketing_ergonomics.rb` | `ruby examples/marketing_ergonomics.rb` | compact domain DSL with `with`, matcher-style `guard`, `scope`/`namespace`, `expose`, `on_success`, and `explain_plan` |
 | `collection.rb` | `ruby examples/collection.rb` | declarative fan-out, stable item keys, and `CollectionResult` |
 | `collection_partial_failure.rb` | `ruby examples/collection_partial_failure.rb` | `:collect` mode, partial failure summary, and collection diagnostics |
-| `ringcentral_routing.rb` | `ruby examples/ringcentral_routing.rb` | top-level `branch`, nested `collection`, per-item routing, and nested diagnostics semantics |
+| `ringcentral_routing.rb` | `ruby examples/ringcentral_routing.rb` | top-level `branch`, nested `collection`, `project`, `aggregate`, `using:`/`map_inputs`, and nested diagnostics semantics |
 
 There are also matching living examples in `spec/igniter/examples_spec.rb`.
 Those are useful if you want to read the examples in test form.

data/docs/API_V2.md

@@ -146,6 +146,12 @@ map :normalized_trade_name, from: :service do |service:|
   service.downcase == "heating" ? "HVAC" : service
 end
 
+project :telephony_status, from: :body, key: "telephonyStatus"
+
+aggregate :available_slots, with: :technicians do |technicians:|
+  technicians.successes.values.sum { |item| item.result.summary[:available_slots] }
+end
+
 guard :business_hours_valid, depends_on: %i[vendor current_time], message: "Closed" do |vendor:, current_time:|
   current_time.between?(vendor.start_at, vendor.stop_at)
 end
@@ -180,6 +186,21 @@ branch :delivery_strategy, with: :country, inputs: {
   on "UA", contract: LocalDeliveryContract
   default contract: DefaultDeliveryContract
 end
+
+branch :status_route,
+  with: :telephony_status,
+  depends_on: %i[extension_id active_calls],
+  map_inputs: ->(selector:, extension_id:, active_calls:) {
+    {
+      extension_id: extension_id,
+      telephony_status: selector,
+      active_calls: active_calls
+    }
+  } do
+  on "CallConnected", contract: CallConnectedContract
+  on "NoCall", contract: NoCallContract
+  default contract: UnknownStatusContract
+end
 ```
 
 Declarative fan-out:
@@ -190,6 +211,43 @@ collection :technicians,
   each: TechnicianContract,
   key: :technician_id,
   mode: :collect
+
+collection :calls,
+  with: :active_calls,
+  each: CallEventContract,
+  key: :session_id,
+  mode: :collect,
+  map_inputs: ->(item:) {
+    {
+      session_id: item.fetch("telephonySessionId"),
+      direction: item.fetch("direction"),
+      from: item.fetch("from"),
+      to: item.fetch("to"),
+      start_time: item.fetch("startTime")
+    }
+  }
+```
+
+For repeated mappers, prefer `using:` over inline lambdas:
+
+```ruby
+collection :company_locations,
+  with: :locations_map,
+  each: CompanyLocationSchedulerContract,
+  key: :location_id,
+  depends_on: %i[services_map property_type date],
+  using: :build_company_location_inputs
+```
+
+```ruby
+branch :status_route,
+  with: :telephony_status,
+  depends_on: %i[extension_id active_calls],
+  using: :build_status_route_inputs do
+  on "CallConnected", contract: CallConnectedContract
+  on "NoCall", contract: NoCallContract
+  default contract: UnknownStatusContract
+end
 ```
 
 Rules:

data/examples/README.md

@@ -181,6 +181,9 @@ Shows:
 
 - top-level routing via `branch`
 - nested fan-out via `collection`
+- trivial field extraction via `project`
+- compact summary building via `aggregate`
+- item input shaping via `collection map_inputs:` or `using:`
 - per-item nested routing via another `branch`
 - `CollectionResult` summary on the selected child contract
 - the practical boundary between parent diagnostics and child diagnostics

data/examples/ringcentral_routing.rb

@@ -104,29 +104,26 @@ class CallConnectedContract < Igniter::Contract
       active_calls.any?
     end
 
-    map :call_inputs, from: :active_calls do |active_calls:|
-      active_calls.map do |call|
-        {
-          session_id: call.fetch("telephonySessionId"),
-          direction: call.fetch("direction"),
-          from: call.fetch("from"),
-          to: call.fetch("to"),
-          start_time: call.fetch("startTime")
-        }
-      end
-    end
-
     collection :calls,
-      with: :call_inputs,
+      with: :active_calls,
       each: CallEventContract,
       key: :session_id,
-      mode: :collect
+      mode: :collect,
+      map_inputs: lambda { |item:|
+        {
+          session_id: item.fetch("telephonySessionId"),
+          direction: item.fetch("direction"),
+          from: item.fetch("from"),
+          to: item.fetch("to"),
+          start_time: item.fetch("startTime")
+        }
+      }
 
     compute :call_summaries, with: :calls do |calls:|
       calls.successes.values.map { |item| item.result.summary }
     end
 
-    compute :routing_summary, with: %i[calls call_summaries extension_id telephony_status has_calls] do |calls:, call_summaries:, extension_id:, telephony_status:, has_calls:|
+    aggregate :routing_summary, with: %i[calls call_summaries extension_id telephony_status has_calls] do |calls:, call_summaries:, extension_id:, telephony_status:, has_calls:|
       has_calls
       {
         extension_id: extension_id,
@@ -204,28 +201,22 @@ class RingcentralWebhookContract < Igniter::Contract
     input :payload
 
     scope :parse do
-      map :body, from: :payload do |payload:|
-        payload.fetch("body", {})
-      end
-
-      map :telephony_status, from: :body do |body:|
-        body["telephonyStatus"]
-      end
-
-      map :extension_id, from: :body do |body:|
-        body["extensionId"]
-      end
-
-      map :active_calls, from: :body do |body:|
-        body["activeCalls"] || []
-      end
+      project :body, from: :payload, key: :body, default: {}
+      project :telephony_status, from: :body, key: "telephonyStatus"
+      project :extension_id, from: :body, key: "extensionId"
+      project :active_calls, from: :body, key: "activeCalls", default: []
     end
 
-    branch :status_route, with: :telephony_status, inputs: {
-      extension_id: :extension_id,
-      telephony_status: :telephony_status,
-      active_calls: :active_calls
-    } do
+    branch :status_route,
+      with: :telephony_status,
+      depends_on: %i[extension_id active_calls],
+      map_inputs: lambda { |selector:, extension_id:, active_calls:|
+        {
+          extension_id: extension_id,
+          telephony_status: selector,
+          active_calls: active_calls
+        }
+      } do
       on "CallConnected", contract: CallConnectedContract
       on "NoCall", contract: NoCallContract
       on "Ringing", contract: RingingContract

data/lib/igniter/compiler/compiled_graph.rb

@@ -66,15 +66,19 @@ module Igniter
             end
             if node.kind == :branch
               base[:selector] = node.selector_dependency
+              base[:depends_on] = node.context_dependencies if node.context_dependencies.any?
               base[:cases] = node.cases.map { |entry| { match: entry[:match], contract: entry[:contract].name } }
               base[:default_contract] = node.default_contract.name
               base[:inputs] = node.input_mapping
+              base[:mapper] = node.input_mapper.to_s if node.input_mapper?
             end
             if node.kind == :collection
               base[:with] = node.source_dependency
+              base[:depends_on] = node.context_dependencies if node.context_dependencies.any?
               base[:each] = node.contract_class.name
               base[:key] = node.key_name
               base[:mode] = node.mode
+              base[:mapper] = node.input_mapper.to_s if node.input_mapper?
             end
             base
           end,
@@ -117,7 +121,9 @@ module Igniter
             {
               name: node.name,
               with: node.selector_dependency,
+              depends_on: node.context_dependencies,
               inputs: node.input_mapping,
+              map_inputs: (node.input_mapper if node.input_mapper?),
               cases: node.cases.map { |entry| { on: entry[:match], contract: entry[:contract] } },
               default: node.default_contract,
               metadata: node.metadata.reject { |key, _| key == :source_location }
@@ -127,9 +133,11 @@ module Igniter
             {
               name: node.name,
               with: node.source_dependency,
+              depends_on: node.context_dependencies,
               each: node.contract_class,
               key: node.key_name,
               mode: node.mode,
+              map_inputs: (node.input_mapper if node.input_mapper?),
               metadata: node.metadata.reject { |key, _| key == :source_location }
             }
           end,

data/lib/igniter/compiler/validators/dependencies_validator.rb

@@ -100,6 +100,8 @@ module Igniter
         end
 
         def validate_branch_input_mapping!(node, child_graph)
+          return if node.input_mapper?
+
           child_input_nodes = child_graph.nodes.select { |child_node| child_node.kind == :input }
           child_input_names = child_input_nodes.map(&:name)
 

data/lib/igniter/contract.rb

@@ -103,6 +103,13 @@ module Igniter
         react_to(:execution_failed, once_per_execution: true, &terminal_hook)
       end
 
+      def present(output_name, with: nil, &block)
+        raise CompileError, "present requires a block or `with:`" unless block || with
+        raise CompileError, "present cannot use both a block and `with:`" if block && with
+
+        own_output_presenters[output_name.to_sym] = with || block
+      end
+
       def compiled_graph
         @compiled_graph || superclass_compiled_graph
       end
@@ -116,8 +123,17 @@ module Igniter
         @execution_options || superclass_execution_options || {}
       end
 
+      def output_presenters
+        inherited = superclass.respond_to?(:output_presenters) ? superclass.output_presenters : {}
+        inherited.merge(own_output_presenters)
+      end
+
       private
 
+      def own_output_presenters
+        @output_presenters ||= {}
+      end
+
       def contract_name
         name || "AnonymousContract"
       end

data/lib/igniter/diagnostics/report.rb

@@ -32,7 +32,7 @@ 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])
@@ -47,7 +47,7 @@ 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('; ')}"
@@ -170,6 +170,13 @@ 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]}"
@@ -203,7 +210,27 @@ module Igniter
       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)
@@ -221,6 +248,78 @@ module Igniter
         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)

data/lib/igniter/dsl/contract_builder.rb

@@ -17,6 +17,7 @@ module Igniter
       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)
@@ -71,6 +72,33 @@ module Igniter
         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)
@@ -156,9 +184,12 @@ module Igniter
         )
       end
 
-      def branch(name, with:, inputs:, **metadata, &block)
+      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 an `inputs:` hash" unless inputs.is_a?(Hash)
+        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)
 
@@ -169,14 +200,18 @@ module Igniter
             selector_dependency: with,
             cases: definition[:cases],
             default_contract: definition[:default_contract],
-            input_mapping: inputs,
+            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, **metadata)
+      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,
@@ -185,6 +220,8 @@ module Igniter
             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)
           )
@@ -254,6 +291,32 @@ module Igniter
         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?
 

data/lib/igniter/extensions/introspection/graph_formatter.rb

@@ -39,14 +39,18 @@ module Igniter
             if node.kind == :branch
               cases = node.cases.map { |entry| "#{entry[:match].inspect}:#{entry[:contract].name || 'AnonymousContract'}" }
               line += " selector=#{node.selector_dependency}"
+              line += " depends_on=#{node.context_dependencies.join(',')}" if node.context_dependencies.any?
               line += " cases=#{cases.join('|')}"
               line += " default=#{node.default_contract.name || 'AnonymousContract'}"
+              line += " mapper=#{node.input_mapper}" if node.input_mapper?
             end
             if node.kind == :collection
               line += " with=#{node.source_dependency}"
+              line += " depends_on=#{node.context_dependencies.join(',')}" if node.context_dependencies.any?
               line += " each=#{node.contract_class.name || 'AnonymousContract'}"
               line += " key=#{node.key_name}"
               line += " mode=#{node.mode}"
+              line += " mapper=#{node.input_mapper}" if node.input_mapper?
             end
             lines << line
           end

data/lib/igniter/model/branch_node.rb

@@ -3,10 +3,10 @@
 module Igniter
   module Model
     class BranchNode < Node
-      attr_reader :selector_dependency, :cases, :default_contract, :input_mapping
+      attr_reader :selector_dependency, :cases, :default_contract, :input_mapping, :context_dependencies, :input_mapper
 
-      def initialize(id:, name:, selector_dependency:, cases:, default_contract:, input_mapping:, path: nil, metadata: {})
-        dependencies = ([selector_dependency] + input_mapping.values).uniq
+      def initialize(id:, name:, selector_dependency:, cases:, default_contract:, input_mapping:, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
+        dependencies = ([selector_dependency] + input_mapping.values + context_dependencies).uniq
 
         super(
           id: id,
@@ -21,12 +21,18 @@ module Igniter
         @cases = cases.map { |entry| normalize_case(entry) }.freeze
         @default_contract = default_contract
         @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
+        @context_dependencies = Array(context_dependencies).map(&:to_sym).freeze
+        @input_mapper = input_mapper
       end
 
       def possible_contracts
         (cases.map { |entry| entry[:contract] } + [default_contract]).uniq
       end
 
+      def input_mapper?
+        !input_mapper.nil?
+      end
+
       private
 
       def normalize_case(entry)

data/lib/igniter/model/collection_node.rb

@@ -3,15 +3,15 @@
 module Igniter
   module Model
     class CollectionNode < Node
-      attr_reader :source_dependency, :contract_class, :key_name, :mode
+      attr_reader :source_dependency, :contract_class, :key_name, :mode, :context_dependencies, :input_mapper
 
-      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, path: nil, metadata: {})
+      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
         super(
           id: id,
           kind: :collection,
           name: name,
           path: (path || name),
-          dependencies: [source_dependency],
+          dependencies: [source_dependency, *context_dependencies],
           metadata: metadata
         )
 
@@ -19,6 +19,12 @@ module Igniter
         @contract_class = contract_class
         @key_name = key_name.to_sym
         @mode = mode.to_sym
+        @context_dependencies = Array(context_dependencies).map(&:to_sym)
+        @input_mapper = input_mapper
+      end
+
+      def input_mapper?
+        !input_mapper.nil?
       end
     end
   end

data/lib/igniter/runtime/resolver.rb

@@ -123,10 +123,18 @@ module Igniter
 
         raise BranchSelectionError, "Branch '#{node.name}' has no matching case and no default" unless selected_contract
 
-        child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
-          memo[child_input_name] = resolve_dependency_value(dependency_name)
+        context_values = node.context_dependencies.each_with_object({}) do |dependency_name, memo|
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
         end
 
+        child_inputs = if node.input_mapper?
+                         map_branch_inputs(node, selector_value, context_values)
+                       else
+                         node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
+                           memo[child_input_name] = resolve_dependency_value(dependency_name)
+                         end
+                       end
+
         @execution.events.emit(
           :branch_selected,
           node: node,
@@ -147,9 +155,22 @@ module Igniter
         NodeState.new(node: node, status: :succeeded, value: child_contract.result)
       end
 
+      def map_branch_inputs(node, selector_value, context_values)
+        mapper = node.input_mapper
+
+        if mapper.is_a?(Symbol) || mapper.is_a?(String)
+          return @execution.contract_instance.public_send(mapper, selector: selector_value, **context_values)
+        end
+
+        mapper.call(selector: selector_value, **context_values)
+      end
+
       def resolve_collection(node)
         items = resolve_dependency_value(node.source_dependency)
-        normalized_items = normalize_collection_items(node, items)
+        context_values = node.context_dependencies.each_with_object({}) do |dependency_name, memo|
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
+        end
+        normalized_items = normalize_collection_items(node, items, context_values)
         collection_items = {}
 
         normalized_items.each do |item_inputs|
@@ -310,7 +331,11 @@ module Igniter
         )
       end
 
-      def normalize_collection_items(node, items)
+      def normalize_collection_items(node, items, context_values = {})
+        if node.input_mapper? && items.is_a?(Hash)
+          items = items.to_a
+        end
+
         unless items.is_a?(Array)
           raise CollectionInputError.new(
             "Collection '#{node.name}' expects an array, got #{items.class}",
@@ -318,7 +343,13 @@ module Igniter
           )
         end
 
-        items.each do |item|
+        mapped_items = if node.input_mapper?
+                         items.map { |item| map_collection_item_inputs(node, item, context_values) }
+                       else
+                         items
+                       end
+
+        mapped_items.each do |item|
           next if item.is_a?(Hash)
 
           raise CollectionInputError.new(
@@ -327,8 +358,18 @@ module Igniter
           )
         end
 
-        ensure_unique_collection_keys!(node, items)
-        items.map { |item| item.transform_keys(&:to_sym) }
+        ensure_unique_collection_keys!(node, mapped_items)
+        mapped_items.map { |item| item.transform_keys(&:to_sym) }
+      end
+
+      def map_collection_item_inputs(node, item, context_values)
+        mapper = node.input_mapper
+
+        if mapper.is_a?(Symbol) || mapper.is_a?(String)
+          return @execution.contract_instance.public_send(mapper, item: item, **context_values)
+        end
+
+        mapper.call(item: item, **context_values)
       end
 
       def extract_collection_key(node, item_inputs)

data/lib/igniter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Igniter
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: igniter
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Alexander