ruby_reactor 0.8.2 → 0.8.4

data/lib/ruby_reactor/retry_context.rb

@@ -3,13 +3,14 @@
 module RubyReactor
   # Tracks retry attempts and state for steps in async execution
   class RetryContext
-    attr_accessor :step_attempts, :current_step, :failure_reason, :next_retry_at
+    attr_accessor :step_attempts, :current_step, :failure_reason, :next_retry_at, :contention_attempts
 
     def initialize
       @step_attempts = {}
       @current_step = nil
       @failure_reason = nil
       @next_retry_at = nil
+      @contention_attempts = {}
     end
 
     def increment_attempt_for_step(step_name)
@@ -18,6 +19,16 @@ module RubyReactor
       @step_attempts[step_name] += 1
     end
 
+    # Undoes one `increment_attempt_for_step` — called at the start of a
+    # contention park (Finding 2) so a busy key never eats the retry budget
+    # meant for genuine failures. Floored at 0.
+    def decrement_attempt_for_step(step_name)
+      step_name = step_name.to_s
+      return unless @step_attempts[step_name]
+
+      @step_attempts[step_name] = [@step_attempts[step_name] - 1, 0].max
+    end
+
     def attempts_for_step(step_name)
       step_name = step_name.to_s
       @step_attempts[step_name] || 0
@@ -28,11 +39,27 @@ module RubyReactor
       attempts < max_attempts
     end
 
+    def increment_contention_for_step(step_name)
+      step_name = step_name.to_s
+      @contention_attempts[step_name] ||= 0
+      @contention_attempts[step_name] += 1
+    end
+
+    def contention_attempts_for_step(step_name)
+      step_name = step_name.to_s
+      @contention_attempts[step_name] || 0
+    end
+
+    def clear_contention_for_step(step_name)
+      @contention_attempts.delete(step_name.to_s)
+    end
+
     def reset
       @step_attempts = {}
       @current_step = nil
       @failure_reason = nil
       @next_retry_at = nil
+      @contention_attempts = {}
     end
 
     def serialize_for_retry
@@ -40,7 +67,8 @@ module RubyReactor
         step_attempts: @step_attempts,
         current_step: @current_step,
         failure_reason: serialize_error(@failure_reason),
-        next_retry_at: @next_retry_at&.iso8601
+        next_retry_at: @next_retry_at&.iso8601,
+        contention_attempts: @contention_attempts
       }
     end
 
@@ -50,6 +78,7 @@ module RubyReactor
       context.current_step = data["current_step"]
       context.failure_reason = deserialize_error(data["failure_reason"])
       context.next_retry_at = data["next_retry_at"] ? Time.iso8601(data["next_retry_at"]) : nil
+      context.contention_attempts = data["contention_attempts"] || {}
       context
     end
 

data/lib/ruby_reactor/rspec/helpers.rb

@@ -19,6 +19,21 @@ module RubyReactor
           process_jobs: process_jobs
         )
       end
+
+      # Holds `key` as an EXTERNAL owner for the duration of the block, so a
+      # spec can assert against genuine lock contention (a step or reactor
+      # failing/parking because something else already holds its key)
+      # without reaching into `RubyReactor::Lock` or raw Redis calls itself.
+      # Released even if the block raises.
+      #
+      #   hold_lock("acct:1") { expect(ChargeStep.run({ account_id: 1 }, nil)).to be_a(RubyReactor::Failure) }
+      def hold_lock(key, owner: "spec", ttl: 30)
+        lock = RubyReactor::Lock.new(key, owner: owner, ttl: ttl, wait: 0, auto_extend: true)
+        lock.acquire
+        yield
+      ensure
+        lock&.release
+      end
     end
   end
 end

data/lib/ruby_reactor/rspec/matchers.rb

@@ -528,6 +528,98 @@ module RubyReactor
         end
       end
 
+      # Asserts a `:contention_park` trace entry exists for a step (US7-4,
+      # T054). Subject can be a `test_reactor` wrapper, a dispatch/find result
+      # (`.context`), or a raw `Context` (`.execution_trace`) — matching
+      # `have_run_step`'s subject flexibility. Use `.on(key)` to pin the key.
+      #
+      #   expect(result).to have_contended_at(:charge)
+      #   expect(result).to have_contended_at(:charge).on("acct:1")
+      ::RSpec::Matchers.define :have_contended_at do |step_name|
+        match do |subject|
+          trace = execution_trace_for(subject)
+          @entry = trace.find do |t|
+            t[:type].to_s == "contention_park" && t[:step].to_s == step_name.to_s &&
+              (@expected_key.nil? || t[:key].to_s == @expected_key.to_s)
+          end
+          !@entry.nil?
+        end
+
+        chain :on do |key|
+          @expected_key = key
+        end
+
+        def execution_trace_for(subject)
+          subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
+          if subject.respond_to?(:reactor_instance)
+            subject.reactor_instance.context.execution_trace
+          elsif subject.respond_to?(:context)
+            subject.context.execution_trace
+          else
+            subject.execution_trace
+          end
+        end
+
+        failure_message do |_subject|
+          msg = "expected execution trace to contain a contention_park entry for step :#{step_name}"
+          msg += " on key #{@expected_key.inspect}" if @expected_key
+          msg
+        end
+
+        failure_message_when_negated do |_subject|
+          msg = "expected execution trace not to contain a contention_park entry for step :#{step_name}"
+          msg += " on key #{@expected_key.inspect}" if @expected_key
+          msg
+        end
+      end
+
+      # Asserts that a failed run reports a rollback (undo or compensation)
+      # of `step_name` that did not complete, on `Failure#rollback_failures`.
+      # Subject is a `Failure` or a `test_reactor` wrapper (its `result`).
+      #
+      #   expect(result).to have_rollback_failure(:charge)
+      #   expect(subject).to have_rollback_failure(:charge).for_key("acct:1").because(:coordination_unavailable)
+      #   expect(subject).not_to have_rollback_failure(:charge)
+      ::RSpec::Matchers.define :have_rollback_failure do |step_name|
+        match do |subject|
+          @entries = rollback_failures_for(subject)
+          @entries.any? do |e|
+            e[:step].to_s == step_name.to_s &&
+              (@expected_key.nil? || e[:key].to_s == @expected_key.to_s) &&
+              (@expected_reason.nil? || e[:reason].to_s == @expected_reason.to_s)
+          end
+        end
+
+        chain :for_key do |key|
+          @expected_key = key
+        end
+
+        chain :because do |reason|
+          @expected_reason = reason
+        end
+
+        def rollback_failures_for(subject)
+          subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
+          actual = subject.respond_to?(:result) ? subject.result : subject
+          actual.respond_to?(:rollback_failures) ? actual.rollback_failures : []
+        end
+
+        def expectation_text(step_name)
+          text = "a rollback failure for :#{step_name}"
+          text += " on key #{@expected_key.inspect}" if @expected_key
+          text += " because #{@expected_reason.inspect}" if @expected_reason
+          text
+        end
+
+        failure_message do |_subject|
+          "expected #{expectation_text(step_name)}, got rollback_failures #{@entries.inspect}"
+        end
+
+        failure_message_when_negated do |_subject|
+          "expected no #{expectation_text(step_name)}, got rollback_failures #{@entries.inspect}"
+        end
+      end
+
       # Add more matchers as per plan
       # rubocop:enable Metrics/BlockLength
     end

data/lib/ruby_reactor/rspec/test_subject.rb

@@ -556,7 +556,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
 
           # 2. Add Name Handling with Unique Registry Entry
           # We must register a unique name so that if this reactor is reloaded (e.g. after async child completion),
@@ -648,7 +647,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
         end
 
         strip_background_and_async!(child_class)
@@ -736,7 +734,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
         end
 
         # Recursively apply interceptors to the child reactor
@@ -765,9 +762,16 @@ module RubyReactor
       # callable a mock block can invoke.
       def original_impl_for(step_config_orig, target_step)
         if step_config_orig.has_run_block?
-          step_config_orig.run_block
+          # A mock may hand `original` a plain Hash (`args.to_h.merge(...)`).
+          ->(args, ctx) { step_config_orig.run_block.call(step_config_orig.wrap_inputs(args), ctx) }
         elsif step_config_orig.has_impl?
-          ->(args, ctx) { step_config_orig.impl.run(args, ctx) }
+          impl = step_config_orig.impl
+
+          if impl.respond_to?(:run_without_coordination)
+            ->(args, ctx) { impl.run_without_coordination(args, ctx) }
+          else
+            ->(args, ctx) { impl.run(args.to_h, ctx) }
+          end
         else
           ->(_, _) { raise "No implementation found for #{target_step}" }
         end

data/lib/ruby_reactor/step/async_reactor_step.rb

@@ -15,9 +15,51 @@ module RubyReactor
     # ordered-lock nonce at ENQUEUE time (so ordering matches caller order), and
     # persist before enqueueing (F2).
     class AsyncReactorStep < RubyReactor::Step
+      # Untyped, so no validation: declared only so `inputs.x` can read them.
+      input :async_reactor_class
+      input :argument_mappings, optional: true
+
+      class << self
+        # Exclusive keys this EXECUTION currently holds, read from the root
+        # context's registry. Shared by the `async_reactor` dispatch check
+        # below (via `detect_lock_deadlock`) and the `async_step` dispatch-time
+        # guard (`Executor::AsyncStepDispatch`, T034) — both hand off work to
+        # a process that will never share this execution's owner, so a key
+        # the execution currently holds would deadlock the dispatched unit.
+        def held_lock_keys(context)
+          root = context.root_context || context
+          Array(root.private_data[:held_lock_keys] || root.private_data["held_lock_keys"])
+        end
+
+        # `kind:` names what is being dispatched ("async_reactor" / "async_step")
+        # so the two guards share one message shape instead of drifting apart.
+        def deadlock_message(key, dispatched_name, context, kind: "async_reactor")
+          parent = context.reactor_class&.name || "the dispatching reactor"
+          <<~MSG.strip
+            #{kind} dispatch of #{dispatched_name || "<anonymous>"} would deadlock: it declares the lock key \
+            '#{key}', which #{parent} currently holds and will not release until it finishes.
+            The child would snooze forever, and if #{parent} later reads this child's result it would wait \
+            for work that can never start. Lock ownership is never shared across the async boundary — the \
+            two run concurrently, so sharing it would break mutual exclusion outright.
+            Fix, in order of preference:
+              1. Use `compose` instead of `async_reactor` if the child belongs inside #{parent}'s critical \
+            section and its result is needed — waiting for it means the work is sequential anyway.
+              2. Narrow the lock keys, if parent and child actually protect different resources.
+              3. Restructure so the locked reactor never reads the child's result — fire-and-forget, and \
+            verify in the child itself or in a successor reactor outside the lock window.#{async_step_remedy(kind)}
+          MSG
+        end
+
+        def async_step_remedy(kind)
+          return "" unless kind == "async_step"
+
+          "\n  4. Run the step inline (drop `async_step`) if it belongs inside the critical section."
+        end
+      end
+
       def run
-        child_class = inputs[:async_reactor_class]
-        child_inputs = build_child_inputs(inputs[:argument_mappings] || {})
+        child_class = inputs.async_reactor_class
+        child_inputs = build_child_inputs(inputs.argument_mappings || {})
 
         # A dispatch-time failure fails the DISPATCHING step, i.e. normal saga
         # handling in the parent. That is deliberately outside the
@@ -60,13 +102,13 @@ module RubyReactor
       # loudly, at dispatch. Ordinary cross-execution contention on the same
       # key is unaffected and still snoozes normally.
       def detect_lock_deadlock(child_class, child_inputs)
-        held = held_lock_keys
+        held = self.class.held_lock_keys(context)
         return nil if held.empty?
 
         collision = child_lock_keys(child_class, child_inputs).find { |key| held.include?(key) }
         return nil unless collision
 
-        RubyReactor.Failure(deadlock_message(collision, child_class))
+        RubyReactor.Failure(self.class.deadlock_message(collision, child_class.name, context))
       end
 
       def child_lock_keys(child_class, child_inputs)
@@ -83,28 +125,6 @@ module RubyReactor
         keys.compact
       end
 
-      def held_lock_keys
-        root = context.root_context || context
-        Array(root.private_data[:held_lock_keys] || root.private_data["held_lock_keys"])
-      end
-
-      def deadlock_message(key, child_class)
-        parent = context.reactor_class&.name || "the dispatching reactor"
-        <<~MSG.strip
-          async_reactor dispatch of #{child_class.name || "<anonymous>"} would deadlock: it declares the \
-          lock key '#{key}', which #{parent} currently holds and will not release until it finishes.
-          The child would snooze forever, and if #{parent} later reads this child's result it would wait \
-          for work that can never start. Lock ownership is never shared across the async boundary — the \
-          two run concurrently, so sharing it would break mutual exclusion outright.
-          Fix, in order of preference:
-            1. Use `compose` instead of `async_reactor` if the child belongs inside #{parent}'s critical \
-          section and its result is needed — waiting for it means the work is sequential anyway.
-            2. Narrow the lock keys, if parent and child actually protect different resources.
-            3. Restructure so the locked reactor never reads the child's result — fire-and-forget, and \
-          verify in the child itself or in a successor reactor outside the lock window.
-        MSG
-      end
-
       # `RSpec::TestSubject`'s `async: false` clears the dispatch marker to run
       # the whole reactor in one process.
       def run_inline?

data/lib/ruby_reactor/step/compose_step.rb

@@ -3,6 +3,10 @@
 module RubyReactor
   class Step
     class ComposeStep < RubyReactor::Step
+      # Untyped, so no validation: declared only so `inputs.x` can read them.
+      input :composed_reactor_class
+      input :argument_mappings, optional: true
+
       def run
         step_name = context.current_step
         composed_data = context.composed_contexts[step_name]
@@ -12,7 +16,7 @@ module RubyReactor
         store_child_context(step_name, child_context)
 
         # Execute the composed reactor
-        result = execute_child_reactor(inputs[:composed_reactor_class], child_context, composed_data)
+        result = execute_child_reactor(inputs.composed_reactor_class, child_context, composed_data)
 
         # Update the stored context
         store_child_context(step_name, child_context)
@@ -21,18 +25,23 @@ module RubyReactor
       end
 
       # Compensating a failed compose and undoing a completed one are the same
-      # work: roll back whatever the child reactor completed.
+      # work: roll back whatever the child reactor completed. Any child undo
+      # that did not complete comes back on the Failure, which the parent's
+      # `CompensationManager` flattens into its own `rollback_failures`.
       def compensate
         step_name = context.current_step
         composed_data = context.composed_contexts[step_name]
         return RubyReactor.Success() unless composed_data && composed_data[:context]
 
         child_context = composed_data[:context]
-        executor = RubyReactor::Executor.new(inputs[:composed_reactor_class], {}, child_context)
+        executor = RubyReactor::Executor.new(inputs.composed_reactor_class, {}, child_context)
         executor.undo_all
         executor.save_context
 
-        RubyReactor.Success()
+        failures = executor.compensation_manager.rollback_failures
+        return RubyReactor.Success() if failures.empty?
+
+        RubyReactor.Failure("composed :#{step_name} rollback incomplete", rollback_failures: failures)
       end
 
       alias undo compensate
@@ -54,8 +63,8 @@ module RubyReactor
         child_context = composed_data ? composed_data[:context] : nil
 
         unless child_context
-          composed_inputs = build_composed_inputs(inputs[:argument_mappings] || {})
-          child_context = RubyReactor::Context.new(composed_inputs, inputs[:composed_reactor_class])
+          composed_inputs = build_composed_inputs(inputs.argument_mappings || {})
+          child_context = RubyReactor::Context.new(composed_inputs, inputs.composed_reactor_class)
         end
 
         link_contexts(child_context, context)
@@ -79,7 +88,13 @@ module RubyReactor
       def execute_child_reactor(composed_reactor, child_context, composed_data)
         executor = RubyReactor::Executor.new(composed_reactor, {}, child_context)
 
-        if composed_data && child_context.current_step
+        # Resume once the child has been admitted, not by its `current_step`:
+        # a park two levels down unwinds the child's `with_step` and clears
+        # it, and `execute` would then re-charge the child's rate limit and
+        # fresh-acquire its lock instead of re-adopting the parked hold
+        # (005 R-02). `current_step` stays as the fallback for a child saved
+        # before `admitted` existed.
+        if composed_data && (child_context.admitted? || child_context.current_step)
           executor.resume_execution
         else
           executor.execute

data/lib/ruby_reactor/step/input_contract.rb

@@ -25,6 +25,11 @@ module RubyReactor
       def input(name, type = nil, optional: false, default: nil, redact: false, validate: nil, **predicates, &block)
         # rubocop:enable Metrics/ParameterLists
         check_dry_validation_available!
+        if Step::Inputs.public_method_defined?(name)
+          raise Error::ValidationError,
+                "input :#{name} is reserved: step code reads inputs as `inputs.#{name}`, and `#{name}` is already " \
+                "a method there. Rename the input."
+        end
         unless default.nil? || optional
           raise Error::ValidationError,
                 "input :#{name} declares `default:` but is required; a default only applies to an " \

data/lib/ruby_reactor/step/inputs.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Step
+    # What step code (`run`, `undo`, `compensate`) receives as its inputs: a
+    # frozen, read-only view of the argument Hash with one reader per name the
+    # step may read. Any other name raises `Error::UndeclaredInputError` on the
+    # line that reads it, instead of returning nil and failing somewhere else.
+    #
+    #   inputs.order_guid      # the value, or nil for an absent optional input
+    #   inputs.order_id        # raises UndeclaredInputError
+    #   inputs.to_h            # supplied values, readable names only
+    #   Service.call(**inputs) # via `to_hash`
+    #
+    # Readable names are the contract's declarations, or the keys present when
+    # the step has none. Built only where inputs reach step code; everything
+    # else in the gem keeps the Hash.
+    class Inputs
+      def initialize(values, contract: nil, owner: nil)
+        @values = values.to_h
+        @owner = owner
+        declared = contract&.declarations&.keys || []
+        @names = declared.empty? ? @values.keys.map(&:to_sym).uniq : declared
+        @redacted = contract&.redacted_names || []
+        freeze
+      end
+
+      def to_h
+        @names.each_with_object({}) do |name, hash|
+          hash[name] = Utils::FetchIndifferent.call(@values, name) if supplied?(name)
+        end
+      end
+      alias to_hash to_h
+
+      def inspect
+        to_h.to_h { |name, value| [name, @redacted.include?(name) ? InputContract::REDACTED : value] }.inspect
+      end
+
+      private
+
+      def method_missing(name, *args)
+        return Utils::FetchIndifferent.call(@values, name) if args.empty? && @names.include?(name)
+
+        declared = @names.empty? ? "none" : @names.map(&:inspect).join(", ")
+        raise Error::UndeclaredInputError.new("#{@owner} has no input :#{name}. Declared inputs: #{declared}.", name)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @names.include?(name) || super
+      end
+
+      def supplied?(name)
+        @values.key?(name) || @values.key?(name.to_s)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/step/map_step.rb

@@ -3,8 +3,18 @@
 module RubyReactor
   class Step
     class MapStep < RubyReactor::Step
+      # Untyped, so no validation: declared only so `inputs.x` can read them.
+      input :source
+      input :mapped_reactor_class
+      input :argument_mappings, optional: true
+      input :strict_ordering, optional: true
+      input :batch_size, optional: true
+      input :collect_block, optional: true
+      input :fail_fast, optional: true
+      input :fan_out, optional: true
+
       def run
-        return RubyReactor::Failure("Map source cannot be nil") if inputs[:source].nil?
+        return RubyReactor::Failure("Map source cannot be nil") if inputs.source.nil?
 
         # Initialize map state in context if not present
         context.map_operations ||= {}
@@ -77,21 +87,21 @@ module RubyReactor
       def fan_out?
         return false if context.map_metadata || context.root_context&.map_metadata
 
-        inputs[:fan_out]
+        inputs.fan_out
       end
 
       def run_inline
         results = execute_inline_map
         return results if results.is_a?(RubyReactor::Failure) || results.is_a?(RubyReactor::Halt)
 
-        process_results(results, inputs[:collect_block], inputs[:fail_fast])
+        process_results(results, inputs.collect_block, inputs.fail_fast)
       end
 
       def execute_inline_map
         results = []
-        fail_fast = inputs[:fail_fast].nil? || inputs[:fail_fast]
+        fail_fast = inputs.fail_fast.nil? || inputs.fail_fast
 
-        inputs[:source].each_with_index do |element, index|
+        inputs.source.each_with_index do |element, index|
           result = execute_single_element(element, index)
 
           # An element-level Halt propagates as a run halt: stop immediately
@@ -110,8 +120,8 @@ module RubyReactor
       end
 
       def execute_single_element(element, index)
-        mapped_inputs = self.class.build_mapped_inputs(inputs[:argument_mappings] || {}, context, element)
-        child_context = RubyReactor::Context.new(mapped_inputs, inputs[:mapped_reactor_class])
+        mapped_inputs = self.class.build_mapped_inputs(inputs.argument_mappings || {}, context, element)
+        child_context = RubyReactor::Context.new(mapped_inputs, inputs.mapped_reactor_class)
 
         link_contexts(child_context, context)
 
@@ -131,10 +141,10 @@ module RubyReactor
           name: context.current_step,
           type: :map_ref,
           map_id: map_id,
-          element_reactor_class: inputs[:mapped_reactor_class].name
+          element_reactor_class: inputs.mapped_reactor_class.name
         }
 
-        executor = RubyReactor::Executor.new(inputs[:mapped_reactor_class], {}, child_context)
+        executor = RubyReactor::Executor.new(inputs.mapped_reactor_class, {}, child_context)
         executor.execute
         executor.result
       end
@@ -162,9 +172,9 @@ module RubyReactor
       def run_async(step_name)
         map_id = "#{context.context_id}:#{step_name}"
         context.map_operations[step_name.to_s] = map_id
-        prepare_async_execution(map_id, inputs[:source].size)
+        prepare_async_execution(map_id, inputs.source.size)
 
-        reactor_class_info = build_reactor_class_info(inputs[:mapped_reactor_class], step_name)
+        reactor_class_info = build_reactor_class_info(inputs.mapped_reactor_class, step_name)
 
         initialize_map_metadata(map_id, reactor_class_info)
 
@@ -175,7 +185,7 @@ module RubyReactor
           name: step_name.to_s,
           type: :map_ref,
           map_id: map_id,
-          element_reactor_class: inputs[:mapped_reactor_class].name
+          element_reactor_class: inputs.mapped_reactor_class.name
         }
 
         RubyReactor::DispatchResult.new(
@@ -188,9 +198,9 @@ module RubyReactor
       def initialize_map_metadata(map_id, reactor_class_info)
         storage = RubyReactor.configuration.storage_adapter
         storage.initialize_map_operation(
-          map_id, inputs[:source].size, context.reactor_class.name,
-          strict_ordering: inputs[:strict_ordering], reactor_class_info: reactor_class_info,
-          **map_recovery_metadata(inputs[:step_name] || context.current_step)
+          map_id, inputs.source.size, context.reactor_class.name,
+          strict_ordering: inputs.strict_ordering, reactor_class_info: reactor_class_info,
+          **map_recovery_metadata(context.current_step)
         )
       end
 
@@ -215,21 +225,21 @@ module RubyReactor
         # own worker, with the map counter/collector tracking completion. This
         # lets elements with async steps or async retries hand off correctly
         # instead of being forced to run synchronously in a single worker.
-        batch_size = inputs[:batch_size] || inputs[:source].size
+        batch_size = inputs.batch_size || inputs.source.size
 
         RubyReactor::Map::Dispatcher.perform(
           map_id: map_id,
           parent_context_id: context.context_id,
           parent_reactor_class_name: context.reactor_class.name,
-          source: inputs[:source],
+          source: inputs.source,
           batch_size: batch_size,
           step_name: step_name,
-          argument_mappings: inputs[:argument_mappings],
-          strict_ordering: inputs[:strict_ordering],
-          mapped_reactor_class: inputs[:mapped_reactor_class],
-          fail_fast: inputs[:fail_fast].nil? || inputs[:fail_fast]
+          argument_mappings: inputs.argument_mappings,
+          strict_ordering: inputs.strict_ordering,
+          mapped_reactor_class: inputs.mapped_reactor_class,
+          fail_fast: inputs.fail_fast.nil? || inputs.fail_fast
         )
-        queue_collector(map_id, step_name, inputs[:strict_ordering])
+        queue_collector(map_id, step_name, inputs.strict_ordering)
         "map:#{map_id}"
       end