ruby_reactor 0.2.0 → 0.3.1

data/lib/ruby_reactor/{async_router.rb → sidekiq_adapter.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RubyReactor
-  class AsyncRouter
+  class SidekiqAdapter
     def self.perform_async(serialized_context, reactor_class_name = nil, intermediate_results: {})
       job_id = SidekiqWorkers::Worker.perform_async(serialized_context, reactor_class_name)
       context = ContextSerializer.deserialize(serialized_context)
@@ -19,8 +19,8 @@ module RubyReactor
     # rubocop:disable Metrics/ParameterLists
     def self.perform_map_element_async(map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
                                        strict_ordering:, parent_context_id:, parent_reactor_class_name:, step_name:,
-                                       batch_size: nil, serialized_context: nil)
-      RubyReactor::SidekiqWorkers::MapElementWorker.perform_async(
+                                       batch_size: nil, serialized_context: nil, fail_fast: nil)
+      job_id = RubyReactor::SidekiqWorkers::MapElementWorker.perform_async(
         {
           "map_id" => map_id,
           "element_id" => element_id,
@@ -32,9 +32,11 @@ module RubyReactor
           "parent_reactor_class_name" => parent_reactor_class_name,
           "step_name" => step_name,
           "batch_size" => batch_size,
-          "serialized_context" => serialized_context
+          "serialized_context" => serialized_context,
+          "fail_fast" => fail_fast
         }
       )
+      RubyReactor::AsyncResult.new(job_id: job_id)
     end
 
     def self.perform_map_element_in(delay, map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
@@ -62,7 +64,7 @@ module RubyReactor
     # rubocop:disable Metrics/ParameterLists
     def self.perform_map_collection_async(parent_context_id:, map_id:, parent_reactor_class_name:, step_name:,
                                           strict_ordering:, timeout:)
-      RubyReactor::SidekiqWorkers::MapCollectorWorker.perform_async(
+      job_id = RubyReactor::SidekiqWorkers::MapCollectorWorker.perform_async(
         {
           "parent_context_id" => parent_context_id,
           "map_id" => map_id,
@@ -72,13 +74,15 @@ module RubyReactor
           "timeout" => timeout
         }
       )
+      RubyReactor::AsyncResult.new(job_id: job_id)
     end
-    # rubocop:enable Metrics/ParameterLists
 
+    # rubocop:enable Metrics/ParameterLists
     # rubocop:disable Metrics/ParameterLists
     def self.perform_map_execution_async(map_id:, serialized_inputs:, reactor_class_info:, strict_ordering:,
-                                         parent_context_id:, parent_reactor_class_name:, step_name:)
-      RubyReactor::SidekiqWorkers::MapExecutionWorker.perform_async(
+                                         parent_context_id:, parent_reactor_class_name:, step_name:, fail_fast: nil)
+      # rubocop:enable Metrics/ParameterLists
+      job_id = RubyReactor::SidekiqWorkers::MapExecutionWorker.perform_async(
         {
           "map_id" => map_id,
           "serialized_inputs" => serialized_inputs,
@@ -86,10 +90,11 @@ module RubyReactor
           "strict_ordering" => strict_ordering,
           "parent_context_id" => parent_context_id,
           "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name
+          "step_name" => step_name,
+          "fail_fast" => fail_fast
         }
       )
+      RubyReactor::AsyncResult.new(job_id: job_id)
     end
-    # rubocop:enable Metrics/ParameterLists
   end
 end

data/lib/ruby_reactor/sidekiq_workers/worker.rb

@@ -39,9 +39,7 @@ module RubyReactor
         executor = Executor.new(context.reactor_class, {}, context)
         executor.resume_execution
         executor.save_context
-
-        # Return the executor (which now has the result stored in it)
-        executor
+        executor.result
       end
 
       private

data/lib/ruby_reactor/step/compose_step.rb

@@ -84,7 +84,6 @@ module RubyReactor
         def link_contexts(child_context, parent_context)
           child_context.parent_context = parent_context
           child_context.root_context = parent_context.root_context || parent_context
-          child_context.test_mode = parent_context.test_mode
           child_context.inline_async_execution = parent_context.inline_async_execution
         end
 

data/lib/ruby_reactor/step/map_step.rb

@@ -28,6 +28,9 @@ module RubyReactor
           inputs = {}
 
           mappings.each do |mapped_input_name, source|
+            # Handle serialized template objects (Hashes from Sidekiq)
+            source = ContextSerializer.deserialize_value(source) if source.is_a?(Hash) && source["_type"]
+
             value = if source.is_a?(RubyReactor::Template::Element)
                       # Handle element reference
                       # For now assuming element() refers to the current map's element
@@ -54,7 +57,9 @@ module RubyReactor
         private
 
         def should_run_async?(arguments, context)
-          arguments[:async] && !context.inline_async_execution
+          return false if context.inline_async_execution
+
+          arguments[:async]
         end
 
         def run_inline(arguments, context)
@@ -115,27 +120,21 @@ module RubyReactor
         def link_contexts(child_context, parent_context)
           child_context.parent_context = parent_context
           child_context.root_context = parent_context.root_context || parent_context
-          child_context.test_mode = parent_context.test_mode
           child_context.inline_async_execution = parent_context.inline_async_execution
         end
 
-        def process_results(results, collect_block, fail_fast = true)
+        def process_results(results, collect_block, _fail_fast = true)
           if collect_block
             begin
               # Collect block receives Result objects when fail_fast is false, values when true
-              RubyReactor::Success(collect_block.call(results))
+              return RubyReactor::Success(collect_block.call(results))
             rescue StandardError => e
-              RubyReactor::Failure(e)
+              return RubyReactor::Failure(e)
             end
-          elsif fail_fast
-            # Default behavior when no collect block
-            # Current behavior: results are already values
-            RubyReactor::Success(results)
-          else
-            # New behavior: extract successful values only
-            successes = results.select(&:success?).map(&:value)
-            RubyReactor::Success(successes)
           end
+
+          # Simplified: both branches returned Success(results)
+          RubyReactor::Success(results)
         end
 
         def extract_path(value, path)
@@ -157,18 +156,9 @@ module RubyReactor
 
           reactor_class_info = build_reactor_class_info(arguments[:mapped_reactor_class], context, step_name)
 
-          job_id = if arguments[:batch_size]
-                     storage = RubyReactor.configuration.storage_adapter
-                     storage.set_last_queued_index(map_id, arguments[:batch_size] - 1, context.reactor_class.name)
-                     queue_fan_out(
-                       map_id: map_id, arguments: arguments, context: context,
-                       reactor_class_info: reactor_class_info, step_name: step_name,
-                       limit: arguments[:batch_size]
-                     )
-                   else
-                     queue_single_worker(map_id: map_id, arguments: arguments, context: context,
-                                         reactor_class_info: reactor_class_info, step_name: step_name)
-                   end
+          initialize_map_metadata(map_id, arguments, context, reactor_class_info)
+
+          job_id = dispatch_async_map(map_id, arguments, context, reactor_class_info, step_name)
 
           # Store reference in composed_contexts so the UI knows where to find elements
           context.composed_contexts[step_name.to_s] = {
@@ -178,7 +168,42 @@ module RubyReactor
             element_reactor_class: arguments[:mapped_reactor_class].name
           }
 
-          RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: context.intermediate_results)
+          RubyReactor::AsyncResult.new(
+            job_id: job_id,
+            intermediate_results: context.intermediate_results,
+            execution_id: context.context_id
+          )
+        end
+
+        def initialize_map_metadata(map_id, arguments, context, reactor_class_info)
+          storage = RubyReactor.configuration.storage_adapter
+          storage.initialize_map_operation(
+            map_id, arguments[:source].size, context.reactor_class.name,
+            strict_ordering: arguments[:strict_ordering], reactor_class_info: reactor_class_info
+          )
+        end
+
+        def dispatch_async_map(map_id, arguments, context, reactor_class_info, step_name)
+          if arguments[:batch_size]
+            # Use new Dispatcher with Backpressure
+            RubyReactor::Map::Dispatcher.perform(
+              map_id: map_id,
+              parent_context_id: context.context_id,
+              parent_reactor_class_name: context.reactor_class.name,
+              source: arguments[:source],
+              batch_size: arguments[:batch_size],
+              step_name: step_name,
+              argument_mappings: arguments[:argument_mappings],
+              strict_ordering: arguments[:strict_ordering],
+              mapped_reactor_class: arguments[:mapped_reactor_class],
+              fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
+            )
+            queue_collector(map_id, context, step_name, arguments[:strict_ordering])
+            "map:#{map_id}"
+          else
+            queue_single_worker(map_id: map_id, arguments: arguments, context: context,
+                                reactor_class_info: reactor_class_info, step_name: step_name)
+          end
         end
 
         def prepare_async_execution(context, map_id, count)
@@ -252,7 +277,7 @@ module RubyReactor
             map_id: map_id, serialized_inputs: serialized_inputs,
             reactor_class_info: reactor_class_info, strict_ordering: arguments[:strict_ordering],
             parent_context_id: context.context_id, parent_reactor_class_name: context.reactor_class.name,
-            step_name: step_name.to_s
+            step_name: step_name.to_s, fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
           )
         end
       end

data/lib/ruby_reactor/storage/redis_adapter.rb

@@ -230,6 +230,61 @@ module RubyReactor
         @redis.get(key)
       end
 
+      def set_map_offset(map_id, offset, reactor_class_name)
+        key = map_offset_key(map_id, reactor_class_name)
+        @redis.set(key, offset, ex: 86_400)
+      end
+
+      def set_map_offset_if_not_exists(map_id, offset, reactor_class_name)
+        key = map_offset_key(map_id, reactor_class_name)
+        @redis.set(key, offset, nx: true, ex: 86_400)
+      end
+
+      def retrieve_map_offset(map_id, reactor_class_name)
+        key = map_offset_key(map_id, reactor_class_name)
+        @redis.get(key)
+      end
+
+      def increment_map_offset(map_id, increment, reactor_class_name)
+        key = map_offset_key(map_id, reactor_class_name)
+        @redis.incrby(key, increment)
+      end
+
+      def retrieve_map_results_batch(map_id, reactor_class_name, offset:, limit:, strict_ordering: true)
+        key = map_results_key(map_id, reactor_class_name)
+
+        if strict_ordering
+          # For Hash based results (indexed), we can use HMGET if we know the keys.
+          # Since we use 0-based index keys, we can generate the keys for the batch.
+          fields = (offset...(offset + limit)).map(&:to_s)
+          results = @redis.hmget(key, *fields)
+
+          # HMGET returns nil for missing fields, compact them?
+          # Or should we respect the holes?
+          # Map results are usually dense.
+          results.compact.map { |r| JSON.parse(r) }
+        else
+          # For List based results
+          # LRANGE uses inclusive ending index
+          end_index = offset + limit - 1
+          results = @redis.lrange(key, offset, end_index)
+          results.map { |r| JSON.parse(r) }
+        end
+      end
+
+      def count_map_results(map_id, reactor_class_name)
+        key = map_results_key(map_id, reactor_class_name)
+        type = @redis.type(key)
+
+        if type == "hash"
+          @redis.hlen(key)
+        elsif type == "list"
+          @redis.llen(key)
+        else
+          0
+        end
+      end
+
       private
 
       def fetch_and_filter_reactors(keys)
@@ -267,6 +322,10 @@ module RubyReactor
         "reactor:#{reactor_class_name}:map:#{map_id}:last_queued_index"
       end
 
+      def map_offset_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:offset"
+      end
+
       def correlation_id_key(correlation_id, reactor_class_name)
         "reactor:#{reactor_class_name}:correlation:#{correlation_id}"
       end

data/lib/ruby_reactor/template/dynamic_source.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class DynamicSource < Base
+      attr_reader :block, :argument_mappings
+
+      def initialize(argument_mappings, &block)
+        super()
+        @block = block
+        @argument_mappings = argument_mappings
+      end
+
+      def resolve(context)
+        args = {}
+        @argument_mappings.each do |name, source|
+          # Handle serialized template objects if necessary, similar to MapStep logic
+          # But here we assume source is a Template object that responds to resolve
+          next if source.is_a?(RubyReactor::Template::Element)
+
+          args[name] = if source.respond_to?(:resolve)
+                         source.resolve(context)
+                       else
+                         source
+                       end
+        end
+
+        @block.call(args, context)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/version.rb

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

data/lib/ruby_reactor/web/api.rb

@@ -24,39 +24,44 @@ module RubyReactor
           r.on String do |reactor_id|
             # GET /api/reactors/:id
             r.get do
-              data = RubyReactor::Configuration.instance.storage_adapter.find_context_by_id(reactor_id)
-              return { error: "Reactor not found" } unless data
+              raw_data = RubyReactor::Configuration.instance.storage_adapter.find_context_by_id(reactor_id)
+              return { error: "Reactor not found" } unless raw_data
 
-              reactor_class = data["reactor_class"] ? Object.const_get(data["reactor_class"]) : nil
+              # Clean data for API usage
+              data = ContextSerializer.deserialize_value(raw_data)
+
+              reactor_class = data[:reactor_class] ? Object.const_get(data[:reactor_class].to_s) : nil
               structure = {}
 
               structure = self.class.build_structure(reactor_class) if reactor_class.respond_to?(:steps)
 
-              {
-                id: data["context_id"],
-                class: data["reactor_class"],
-                status: if %w[failed paused completed running].include?(data["status"])
-                          data["status"]
-                        elsif data["cancelled"]
+              response_data = {
+                id: data[:context_id],
+                class: data[:reactor_class].to_s,
+                status: if %w[failed paused completed running].include?(data[:status].to_s)
+                          data[:status].to_s
+                        elsif data[:cancelled]
                           "cancelled"
                         else
-                          (data["current_step"] ? "running" : "completed")
+                          (data[:current_step] ? "running" : "completed")
                         end,
-                current_step: data["current_step"],
-                retry_count: data["retry_count"] || 0,
-                undo_stack: data["undo_stack"] || [],
-                step_attempts: data.dig("retry_context", "step_attempts") || {},
-                created_at: data["started_at"],
-                inputs: data["inputs"],
-                intermediate_results: data["intermediate_results"],
+                current_step: data[:current_step].to_s,
+                retry_count: data[:retry_count] || 0,
+                undo_stack: data[:undo_stack] || [],
+                step_attempts: data.dig(:retry_context, :step_attempts) || {},
+                created_at: data[:started_at],
+                inputs: data[:inputs],
+                intermediate_results: data[:intermediate_results],
                 structure: structure,
-                steps: data["execution_trace"] || [],
+                steps: data[:execution_trace] || [],
                 composed_contexts: self.class.hydrate_composed_contexts(
-                  data["composed_contexts"] || {},
-                  data["reactor_class"]
+                  data[:composed_contexts] || {},
+                  data[:reactor_class]&.to_s
                 ),
-                error: data["failure_reason"]
+                error: data[:failure_reason]
               }
+
+              ContextSerializer.simplify_for_api(response_data)
             end
 
             # POST /api/reactors/:id/retry
@@ -159,7 +164,8 @@ module RubyReactor
         return {} unless composed_contexts.is_a?(Hash)
 
         composed_contexts.transform_values do |value|
-          if ["map_ref", :map_ref].include?(value["type"])
+          type = value[:type] || value["type"]
+          if ["map_ref", :map_ref].include?(type)
             hydrate_map_ref(value, reactor_class_name)
           else
             value
@@ -169,10 +175,12 @@ module RubyReactor
 
       def self.hydrate_map_ref(ref_data, reactor_class_name)
         storage = RubyReactor.configuration.storage_adapter
-        map_id = ref_data["map_id"]
+        map_id = ref_data[:map_id] || ref_data["map_id"]
 
         # Use the specific element reactor class if available, otherwise fallback to parent
-        target_reactor_class = ref_data["element_reactor_class"] || reactor_class_name
+        target_reactor_class = ref_data[:element_reactor_class] ||
+                               ref_data["element_reactor_class"] ||
+                               reactor_class_name
 
         # 1. Check for specific failure (O(1))
         # Stored by ResultHandler when a map element fails

data/lib/ruby_reactor.rb

@@ -20,7 +20,7 @@ rescue LoadError
 end
 
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect("api" => "API")
+loader.inflector.inflect("api" => "API", "rspec" => "RSpec")
 loader.setup
 
 module RubyReactor
@@ -39,20 +39,42 @@ module RubyReactor
     def failure?
       false
     end
+
+    def to_h
+      { success: true, value: @value }
+    end
   end
 
   class Failure
     attr_reader :error, :retryable, :step_name, :inputs, :backtrace, :reactor_name, :step_arguments, :exception_class,
                 :file_path, :line_number, :code_snippet, :validation_errors
 
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def initialize(error, retryable: nil, step_name: nil, inputs: {}, backtrace: nil, redact_inputs: [],
                    reactor_name: nil, step_arguments: {}, exception_class: nil,
                    file_path: nil, line_number: nil, code_snippet: nil, invalid_payload: false, validation_errors: nil)
-      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       @error = error
+
+      # Handle case where error is a serialized hash (e.g. from async failure propagation)
+      if @error.is_a?(Hash)
+        attributes = extract_attributes_from_hash(@error)
+        @error = attributes[:error]
+        retryable = attributes[:retryable] if retryable.nil?
+        step_name ||= attributes[:step_name]
+        reactor_name ||= attributes[:reactor_name]
+        inputs = attributes[:inputs] if inputs.empty?
+        step_arguments = attributes[:step_arguments] if step_arguments.empty?
+        raw_backtrace ||= attributes[:backtrace] || backtrace
+        exception_class ||= attributes[:exception_class]
+        file_path ||= attributes[:file_path]
+        line_number ||= attributes[:line_number]
+        code_snippet ||= attributes[:code_snippet]
+        validation_errors ||= attributes[:validation_errors]
+      end
+
       @retryable = if retryable.nil?
-                     error.respond_to?(:retryable?) ? error.retryable? : true
+                     @error.respond_to?(:retryable?) ? @error.retryable? : true
                    else
                      retryable
                    end
@@ -60,10 +82,10 @@ module RubyReactor
       @reactor_name = reactor_name
       @inputs = inputs
       @step_arguments = step_arguments
-      raw_backtrace = backtrace || (error.respond_to?(:backtrace) ? error.backtrace : caller)
+      raw_backtrace ||= backtrace || (@error.respond_to?(:backtrace) ? @error.backtrace : caller)
       @backtrace = filter_backtrace(raw_backtrace)
       @redact_inputs = redact_inputs
-      @exception_class = exception_class || (error.is_a?(Exception) ? error.class.name : nil)
+      @exception_class = exception_class || (@error.is_a?(Exception) ? @error.class.name : nil)
       @file_path = file_path
       @line_number = line_number
       @code_snippet = code_snippet
@@ -99,6 +121,28 @@ module RubyReactor
       msg.join("\n")
     end
 
+    def to_s
+      message
+    end
+
+    def to_h
+      {
+        success: false,
+        error: error_message,
+        step_name: @step_name,
+        inputs: @inputs,
+        redact_inputs: @redact_inputs,
+        reactor_name: @reactor_name,
+        step_arguments: @step_arguments,
+        exception_class: @exception_class,
+        file_path: @file_path,
+        line_number: @line_number,
+        code_snippet: @code_snippet,
+        validation_errors: @validation_errors,
+        backtrace: @backtrace
+      }
+    end
+
     private
 
     def build_header
@@ -147,10 +191,6 @@ module RubyReactor
       msg << backtrace.take(10).map { |line| "  #{line}" }.join("\n")
     end
 
-    def to_s
-      message
-    end
-
     def filter_backtrace(backtrace)
       return backtrace if ENV["RUBY_REACTOR_DEBUG"] == "true"
       return backtrace if backtrace.nil? || backtrace.empty?
@@ -177,6 +217,26 @@ module RubyReactor
     def error_message
       @error.respond_to?(:message) ? @error.message : @error.to_s
     end
+
+    def extract_attributes_from_hash(error_hash)
+      # Ensure indifferent access
+      err = ->(k) { error_hash[k.to_s] || error_hash[k.to_sym] }
+
+      {
+        error: err[:message] || err[:error] || error_hash,
+        retryable: err[:retryable],
+        step_name: err[:step_name],
+        reactor_name: err[:reactor_name],
+        inputs: err[:inputs] || {},
+        step_arguments: err[:step_arguments] || {},
+        backtrace: err[:backtrace],
+        exception_class: err[:exception_class],
+        file_path: err[:file_path],
+        line_number: err[:line_number],
+        code_snippet: err[:code_snippet],
+        validation_errors: err[:validation_errors]
+      }
+    end
   end
 
   # Async result for background job execution

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_reactor
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Artur
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-07 00:00:00.000000000 Z
+date: 2026-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -108,6 +108,7 @@ files:
 - documentation/images/payment_workflow.png
 - documentation/interrupts.md
 - documentation/retry_configuration.md
+- documentation/testing.md
 - gui/.gitignore
 - gui/README.md
 - gui/eslint.config.js
@@ -139,7 +140,6 @@ files:
 - gui/vite.config.ts
 - gui/vitest.config.ts
 - lib/ruby_reactor.rb
-- lib/ruby_reactor/async_router.rb
 - lib/ruby_reactor/configuration.rb
 - lib/ruby_reactor/context.rb
 - lib/ruby_reactor/context_serializer.rb
@@ -171,14 +171,22 @@ files:
 - lib/ruby_reactor/executor/step_executor.rb
 - lib/ruby_reactor/interrupt_result.rb
 - lib/ruby_reactor/map/collector.rb
+- lib/ruby_reactor/map/dispatcher.rb
 - lib/ruby_reactor/map/element_executor.rb
 - lib/ruby_reactor/map/execution.rb
 - lib/ruby_reactor/map/helpers.rb
+- lib/ruby_reactor/map/result_enumerator.rb
 - lib/ruby_reactor/max_retries_exhausted_failure.rb
 - lib/ruby_reactor/reactor.rb
 - lib/ruby_reactor/registry.rb
 - lib/ruby_reactor/retry_context.rb
 - lib/ruby_reactor/retry_queued_result.rb
+- lib/ruby_reactor/rspec.rb
+- lib/ruby_reactor/rspec/helpers.rb
+- lib/ruby_reactor/rspec/matchers.rb
+- lib/ruby_reactor/rspec/step_executor_patch.rb
+- lib/ruby_reactor/rspec/test_subject.rb
+- lib/ruby_reactor/sidekiq_adapter.rb
 - lib/ruby_reactor/sidekiq_workers/map_collector_worker.rb
 - lib/ruby_reactor/sidekiq_workers/map_element_worker.rb
 - lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb
@@ -190,6 +198,7 @@ files:
 - lib/ruby_reactor/storage/configuration.rb
 - lib/ruby_reactor/storage/redis_adapter.rb
 - lib/ruby_reactor/template/base.rb
+- lib/ruby_reactor/template/dynamic_source.rb
 - lib/ruby_reactor/template/element.rb
 - lib/ruby_reactor/template/input.rb
 - lib/ruby_reactor/template/result.rb