ruby_reactor 0.3.0 → 0.3.1

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

@@ -57,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)
@@ -118,30 +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
-            # New behavior: extract successful values only IF fail_fast is true behavior implies only values
-            # However, if fail_fast is false, we want to return results as is, or if logic dictates otherwise.
-            # wait, if fail_fast=false, we expect Result objects so we can check if success/failure.
-            # If we return only successes, we hide failures.
-            RubyReactor::Success(results)
           end
+
+          # Simplified: both branches returned Success(results)
+          RubyReactor::Success(results)
         end
 
         def extract_path(value, path)
@@ -203,7 +196,7 @@ module RubyReactor
               argument_mappings: arguments[:argument_mappings],
               strict_ordering: arguments[:strict_ordering],
               mapped_reactor_class: arguments[:mapped_reactor_class],
-              fail_fast: arguments[:fail_fast]
+              fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
             )
             queue_collector(map_id, context, step_name, arguments[:strict_ordering])
             "map:#{map_id}"
@@ -284,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, fail_fast: arguments[:fail_fast]
+            step_name: step_name.to_s, fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
           )
         end
       end

data/lib/ruby_reactor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyReactor
-  VERSION = "0.3.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.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Artur
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-13 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
@@ -181,6 +181,12 @@ files:
 - 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