ruby_reactor 0.1.0 → 0.3.0

data/lib/ruby_reactor/async_router.rb

@@ -4,18 +4,22 @@ module RubyReactor
   class AsyncRouter
     def self.perform_async(serialized_context, reactor_class_name = nil, intermediate_results: {})
       job_id = SidekiqWorkers::Worker.perform_async(serialized_context, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results)
+      context = ContextSerializer.deserialize(serialized_context)
+      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                   execution_id: context.context_id)
     end
 
     def self.perform_in(delay, serialized_context, reactor_class_name = nil, intermediate_results: {})
       job_id = SidekiqWorkers::Worker.perform_in(delay, serialized_context, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results)
+      context = ContextSerializer.deserialize(serialized_context)
+      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                   execution_id: context.context_id)
     end
 
     # 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)
+                                       batch_size: nil, serialized_context: nil, fail_fast: nil)
       RubyReactor::SidekiqWorkers::MapElementWorker.perform_async(
         {
           "map_id" => map_id,
@@ -28,7 +32,8 @@ 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
         }
       )
     end
@@ -71,9 +76,8 @@ module RubyReactor
     end
     # 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:)
+                                         parent_context_id:, parent_reactor_class_name:, step_name:, fail_fast: nil)
       RubyReactor::SidekiqWorkers::MapExecutionWorker.perform_async(
         {
           "map_id" => map_id,
@@ -82,10 +86,10 @@ 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
         }
       )
     end
-    # rubocop:enable Metrics/ParameterLists
   end
 end

data/lib/ruby_reactor/context.rb

@@ -4,7 +4,8 @@ module RubyReactor
   class Context
     attr_accessor :inputs, :intermediate_results, :private_data, :current_step, :retry_count, :concurrency_key,
                   :retry_context, :reactor_class, :execution_trace, :inline_async_execution, :undo_stack, :test_mode,
-                  :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata
+                  :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata,
+                  :cancelled, :cancellation_reason, :parent_context_id, :status, :failure_reason
 
     def initialize(inputs = {}, reactor_class = nil)
       @context_id = SecureRandom.uuid
@@ -23,7 +24,12 @@ module RubyReactor
       @inline_async_execution = false # Flag to prevent nested async calls
       @undo_stack = [] # Initialize the undo stack
       @test_mode = false
+      @cancelled = false
+      @cancellation_reason = nil
+      @status = "pending"
+      @failure_reason = nil
       @parent_context = nil
+      @parent_context_id = nil
       @root_context = nil
     end
 
@@ -37,6 +43,7 @@ module RubyReactor
         value
       end
     end
+    alias input get_input
 
     def get_result(step_name, path = nil)
       value = @intermediate_results[step_name.to_sym] || @intermediate_results[step_name.to_s]
@@ -48,6 +55,7 @@ module RubyReactor
         value
       end
     end
+    alias result get_result
 
     def set_result(step_name, value)
       @intermediate_results[step_name.to_sym] = value
@@ -73,7 +81,9 @@ module RubyReactor
         retry_context: @retry_context,
         reactor_class: @reactor_class,
         execution_trace: @execution_trace,
-        test_mode: @test_mode
+        test_mode: @test_mode,
+        status: @status,
+        failure_reason: @failure_reason
       }
     end
 
@@ -95,14 +105,19 @@ module RubyReactor
         retry_context: @retry_context.serialize_for_retry,
         execution_trace: ContextSerializer.serialize_value(@execution_trace),
         undo_stack: serialize_undo_stack,
-        test_mode: @test_mode
+        test_mode: @test_mode,
+        cancelled: @cancelled,
+        cancellation_reason: @cancellation_reason,
+        status: @status,
+        failure_reason: ContextSerializer.serialize_value(@failure_reason),
+        parent_context_id: @parent_context&.context_id || @parent_context_id
       }
     end
 
     def self.deserialize_from_retry(data)
       context = new
       context.context_id = data["context_id"] if data["context_id"]
-      context.reactor_class = data["reactor_class"] ? Object.const_get(data["reactor_class"]) : nil
+      context.reactor_class = resolve_reactor_class(data["reactor_class"])
       context.inputs = ContextSerializer.deserialize_value(data["inputs"]) || {}
       context.intermediate_results = ContextSerializer.deserialize_value(data["intermediate_results"]) || {}
       context.private_data = ContextSerializer.deserialize_value(data["private_data"]) || {}
@@ -116,15 +131,26 @@ module RubyReactor
       context.execution_trace = ContextSerializer.deserialize_value(data["execution_trace"]) || []
       context.undo_stack = deserialize_undo_stack(data["undo_stack"] || [], context.reactor_class)
       context.test_mode = data["test_mode"] || false
-
-      # Reconstruct parent/root relationships if nested contexts exist in private_data
-      # This is tricky because private_data is just a hash.
-      # We rely on the fact that nested contexts are stored in private_data by ComposeStep
-      # But here we just deserialize the values.
+      context.cancelled = data["cancelled"] || false
+      context.cancellation_reason = data["cancellation_reason"]
+      context.status = data["status"] || "pending"
+      context.failure_reason = ContextSerializer.deserialize_value(data["failure_reason"])
+      context.parent_context_id = data["parent_context_id"]
 
       context
     end
 
+    def self.resolve_reactor_class(name)
+      return nil unless name
+
+      begin
+        Object.const_get(name)
+      rescue NameError
+        # Try finding in registry for anonymous classes
+        RubyReactor::Registry.find(name)
+      end
+    end
+
     private
 
     def extract_path(value, path)

data/lib/ruby_reactor/context_serializer.rb

@@ -68,6 +68,14 @@ module RubyReactor
           { "_type" => "Template::Value", "value" => serialize_value(value.instance_variable_get(:@value)) }
         when RubyReactor::Template::Result
           { "_type" => "Template::Result", "step_name" => value.step_name.to_s, "path" => value.path }
+        when RubyReactor::Map::ResultEnumerator
+          {
+            "_type" => "Map::ResultEnumerator",
+            "map_id" => value.map_id,
+            "reactor_class_name" => value.reactor_class_name,
+            "strict_ordering" => value.strict_ordering,
+            "batch_size" => value.batch_size
+          }
         when Hash
           value.transform_keys(&:to_s).transform_values { |v| serialize_value(v) }
         when Array
@@ -115,6 +123,13 @@ module RubyReactor
               RubyReactor::Template::Value.new(deserialize_value(value["value"]))
             when "Template::Result"
               RubyReactor::Template::Result.new(value["step_name"], value["path"])
+            when "Map::ResultEnumerator"
+              RubyReactor::Map::ResultEnumerator.new(
+                value["map_id"],
+                value["reactor_class_name"],
+                strict_ordering: value["strict_ordering"],
+                batch_size: value["batch_size"]
+              )
             else
               value
             end

data/lib/ruby_reactor/dependency_graph.rb

@@ -2,6 +2,8 @@
 
 module RubyReactor
   class DependencyGraph
+    attr_reader :dependencies, :completed
+
     def initialize
       @nodes = {}
       @edges = {}

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -10,6 +10,14 @@ module RubyReactor
       def initialize(name, composed_reactor_class = nil, reactor = nil, &block)
         @name = name
         @composed_reactor_class = composed_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        if @composed_reactor_class && @composed_reactor_class.name.nil? && reactor
+          step_name_camel = name.to_s.split("_").map(&:capitalize).join
+          parent_name = reactor.name
+
+          full_name = "#{parent_name}::#{step_name_camel}"
+          @composed_reactor_class.define_singleton_method(:name) { full_name }
+          RubyReactor::Registry.register(full_name, @composed_reactor_class)
+        end
         @reactor = reactor
         @argument_mappings = {}
         @async = false

data/lib/ruby_reactor/dsl/interrupt_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class InterruptBuilder < StepBuilder
+      def initialize(name, reactor = nil)
+        super(name, nil, reactor)
+        @correlation_id_block = nil
+        @timeout_config = nil
+        @validation_schema = nil
+        @max_attempts = 1
+      end
+
+      def max_attempts(count)
+        @max_attempts = count
+      end
+
+      def correlation_id(&block)
+        @correlation_id_block = block
+      end
+
+      def timeout(seconds, strategy: :lazy)
+        @timeout_config = { duration: seconds, strategy: strategy }
+      end
+
+      def validate(&block)
+        check_dry_validation_available!
+        @validation_schema = build_validation_schema(&block)
+      end
+
+      def build
+        step_config = {
+          name: @name,
+          correlation_id_block: @correlation_id_block,
+          timeout_config: @timeout_config,
+          validation_schema: @validation_schema,
+          max_attempts: @max_attempts,
+          dependencies: @dependencies,
+          async: false, # Interrupts are effectively boundaries, not async jobs themselves (until resumed)
+          conditions: @conditions,
+          guards: @guards
+        }
+
+        RubyReactor::Dsl::InterruptStepConfig.new(step_config)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/interrupt_step_config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class InterruptStepConfig < StepConfig
+      attr_reader :correlation_id_block, :timeout_config, :validation_schema, :strategy, :max_attempts
+
+      def initialize(config)
+        super
+        @correlation_id_block = config[:correlation_id_block]
+        @timeout_config = config[:timeout_config]
+        @validation_schema = config[:validation_schema]
+        @max_attempts = config[:max_attempts] || 1
+      end
+
+      def interrupt?
+        true
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/map_builder.rb

@@ -10,6 +10,14 @@ module RubyReactor
       def initialize(name, mapped_reactor_class = nil, reactor = nil, &block)
         @name = name
         @mapped_reactor_class = mapped_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        if @mapped_reactor_class && @mapped_reactor_class.name.nil? && reactor
+          map_name_camel = name.to_s.split("_").map(&:capitalize).join
+          parent_name = reactor.name # Assuming reactor has a name method or is a class with a name.
+
+          full_name = "#{parent_name}::#{map_name_camel}"
+          @mapped_reactor_class.define_singleton_method(:name) { full_name }
+          RubyReactor::Registry.register(full_name, @mapped_reactor_class)
+        end
         @reactor = reactor
         @argument_mappings = {}
         @async = false
@@ -24,8 +32,12 @@ module RubyReactor
         @argument_mappings[mapped_input_name] = source
       end
 
-      def source(enumerable)
-        @source_enumerable = enumerable
+      def source(enumerable = nil, &block)
+        @source_enumerable = if block
+                               RubyReactor::Template::DynamicSource.new(@argument_mappings, &block)
+                             else
+                               enumerable
+                             end
       end
 
       def async(async = true, batch_size: nil)

data/lib/ruby_reactor/dsl/reactor.rb

@@ -18,6 +18,9 @@ module RubyReactor
         include RubyReactor::Dsl::TemplateHelpers
         include RubyReactor::Dsl::ValidationHelpers
 
+        require_relative "interrupt_builder"
+        require_relative "interrupt_step_config"
+
         def inputs
           @inputs ||= {}
         end
@@ -106,6 +109,15 @@ module RubyReactor
           step_config
         end
 
+        def interrupt(name, &block)
+          builder = RubyReactor::Dsl::InterruptBuilder.new(name, self)
+          builder.instance_eval(&block) if block_given?
+
+          step_config = builder.build
+          steps[name] = step_config
+          step_config
+        end
+
         def returns(step_name)
           @return_step = step_name
         end

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -172,6 +172,10 @@ module RubyReactor
         @conditions.all? { |condition| condition.call(context) } &&
           @guards.all? { |guard| guard.call(context) }
       end
+
+      def interrupt?
+        false
+      end
     end
   end
 end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -5,14 +5,17 @@ module RubyReactor
     class CompensationManager
       def initialize(context)
         @context = context
-        @undo_stack = []
         @undo_trace = []
       end
 
-      attr_reader :undo_stack, :undo_trace
+      def undo_stack
+        @context.undo_stack
+      end
+
+      attr_reader :undo_trace
 
       def add_to_undo_stack(step_info)
-        @undo_stack << step_info
+        @context.undo_stack << step_info
       end
 
       def handle_step_failure(step_config, error, arguments)
@@ -36,43 +39,73 @@ module RubyReactor
       end
 
       def rollback_completed_steps
-        @undo_stack.reverse_each do |step_info|
-          result = undo_step(step_info[:step], step_info[:result], step_info[:arguments])
+        undo_stack.reverse_each do |step_info|
+          result = @context.with_step(step_info[:step].name) do
+            undo_step(step_info[:step], step_info[:result], step_info[:arguments])
+          end
           @undo_trace << { type: :undo, step: step_info[:step].name, result: result,
                            arguments: step_info[:arguments] }
         end
-        @undo_stack.clear
+        undo_stack.clear
       end
 
       private
 
       def compensate_step(step_config, error, arguments)
-        if step_config.compensate_block
-          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
-                                        arguments: arguments }
-          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
-          step_config.compensate_block.call(error, arguments, @context)
-        elsif step_config.has_impl?
-          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
-                                        arguments: arguments }
-          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
-          step_config.impl.compensate(error, arguments, @context)
-        else
-          RubyReactor.Success() # Default compensation
-        end
+        compensate_result = if step_config.compensate_block
+                              step_config.compensate_block.call(error, arguments, @context)
+                            elsif step_config.has_impl?
+                              step_config.impl.compensate(error, arguments, @context)
+                            else
+                              RubyReactor.Success() # Default compensation
+                            end
+
+        # Ensure we have a value to log
+        logged_result = if compensate_result.respond_to?(:value)
+                          compensate_result.value
+                        elsif compensate_result.respond_to?(:error)
+                          compensate_result.error
+                        else
+                          compensate_result
+                        end
+
+        @context.execution_trace << {
+          type: :compensate,
+          step: step_config.name,
+          timestamp: Time.now,
+          result: logged_result,
+          arguments: arguments
+        }
+        @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
+        compensate_result
       end
 
       def undo_step(step_config, result, arguments)
-        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: result.value,
+        undo_result = if step_config.undo_block
+                        step_config.undo_block.call(result.value, arguments, @context)
+                      elsif step_config.has_impl?
+                        step_config.impl.undo(result.value, arguments, @context)
+                      else
+                        RubyReactor.Success()
+                      end
+
+        # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
+        logged_result = if undo_result.respond_to?(:value)
+                          undo_result.value
+                        elsif undo_result.respond_to?(:error)
+                          undo_result.error
+                        else
+                          undo_result
+                        end
+
+        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: logged_result,
                                       arguments: arguments }
-        if step_config.undo_block
-          step_config.undo_block.call(result.value, arguments, @context)
-        elsif step_config.has_impl?
-          step_config.impl.undo(result.value, arguments, @context)
-        end
-      rescue StandardError
+        undo_result
+      rescue StandardError => e
         # Log undo failure but don't halt the rollback process
-        # In a real implementation, this would use a logger
+        @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
+                                      error: e.message }
+        RubyReactor.Failure(e)
       end
     end
   end

data/lib/ruby_reactor/executor/graph_manager.rb

@@ -3,6 +3,8 @@
 module RubyReactor
   class Executor
     class GraphManager
+      attr_reader :dependency_graph
+
       def initialize(reactor_class, dependency_graph, context)
         @reactor_class = reactor_class
         @dependency_graph = dependency_graph