ruby_reactor 0.1.0

data/lib/ruby_reactor/context.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+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
+
+    def initialize(inputs = {}, reactor_class = nil)
+      @context_id = SecureRandom.uuid
+      @inputs = inputs
+      @intermediate_results = {}
+      @private_data = {}
+      @composed_contexts = {}
+      @map_operations = {}
+      @map_metadata = nil
+      @current_step = nil
+      @retry_count = 0
+      @concurrency_key = nil
+      @retry_context = RetryContext.new
+      @reactor_class = reactor_class
+      @execution_trace = []
+      @inline_async_execution = false # Flag to prevent nested async calls
+      @undo_stack = [] # Initialize the undo stack
+      @test_mode = false
+      @parent_context = nil
+      @root_context = nil
+    end
+
+    def get_input(name, path = nil)
+      value = @inputs[name.to_sym] || @inputs[name.to_s]
+      return nil if value.nil?
+
+      if path
+        extract_path(value, path)
+      else
+        value
+      end
+    end
+
+    def get_result(step_name, path = nil)
+      value = @intermediate_results[step_name.to_sym] || @intermediate_results[step_name.to_s]
+      return nil if value.nil?
+
+      if path
+        extract_path(value, path)
+      else
+        value
+      end
+    end
+
+    def set_result(step_name, value)
+      @intermediate_results[step_name.to_sym] = value
+    end
+
+    def with_step(step_name)
+      old_step = @current_step
+      @current_step = step_name
+      yield
+    ensure
+      @current_step = old_step
+    end
+
+    def to_h
+      {
+        inputs: @inputs,
+        intermediate_results: @intermediate_results,
+        composed_contexts: @composed_contexts,
+        map_operations: @map_operations,
+        map_metadata: @map_metadata,
+        current_step: @current_step,
+        retry_count: @retry_count,
+        retry_context: @retry_context,
+        reactor_class: @reactor_class,
+        execution_trace: @execution_trace,
+        test_mode: @test_mode
+      }
+    end
+
+    def serialize_for_retry(job_id: nil, started_at: nil)
+      {
+        job_id: job_id,
+        context_id: @context_id,
+        started_at: (started_at || Time.now).iso8601,
+        reactor_class: @reactor_class&.name,
+        inputs: ContextSerializer.serialize_value(@inputs),
+        intermediate_results: ContextSerializer.serialize_value(@intermediate_results),
+        private_data: ContextSerializer.serialize_value(@private_data),
+        composed_contexts: ContextSerializer.serialize_value(@composed_contexts),
+        map_operations: ContextSerializer.serialize_value(@map_operations),
+        map_metadata: ContextSerializer.serialize_value(@map_metadata),
+        current_step: @current_step,
+        retry_count: @retry_count,
+        concurrency_key: @concurrency_key,
+        retry_context: @retry_context.serialize_for_retry,
+        execution_trace: ContextSerializer.serialize_value(@execution_trace),
+        undo_stack: serialize_undo_stack,
+        test_mode: @test_mode
+      }
+    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.inputs = ContextSerializer.deserialize_value(data["inputs"]) || {}
+      context.intermediate_results = ContextSerializer.deserialize_value(data["intermediate_results"]) || {}
+      context.private_data = ContextSerializer.deserialize_value(data["private_data"]) || {}
+      context.composed_contexts = ContextSerializer.deserialize_value(data["composed_contexts"]) || {}
+      context.map_operations = ContextSerializer.deserialize_value(data["map_operations"]) || {}
+      context.map_metadata = ContextSerializer.deserialize_value(data["map_metadata"])
+      context.current_step = data["current_step"]&.to_sym
+      context.retry_count = data["retry_count"] || 0
+      context.concurrency_key = data["concurrency_key"]
+      context.retry_context = RetryContext.deserialize_from_retry(data["retry_context"] || {})
+      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
+    end
+
+    private
+
+    def extract_path(value, path)
+      if path.is_a?(Symbol) && value.respond_to?(:[])
+        value[path]
+      elsif path.is_a?(String)
+        path.split(".").reduce(value) { |v, key| v&.send(:[], key) }
+      elsif path.is_a?(Array)
+        path.reduce(value) { |v, key| v&.send(:[], key) }
+      elsif value.respond_to?(path)
+        value.send(path)
+      end
+    end
+
+    def serialize_undo_stack
+      @undo_stack.map do |item|
+        {
+          step_name: item[:step].name,
+          arguments: ContextSerializer.serialize_value(item[:arguments]),
+          result: ContextSerializer.serialize_value(item[:result])
+        }
+      end
+    end
+
+    def self.deserialize_undo_stack(data, reactor_class)
+      return [] unless reactor_class
+
+      data.map do |item|
+        step_config = reactor_class.steps[item["step_name"].to_sym]
+        next nil unless step_config
+
+        {
+          step: step_config,
+          arguments: ContextSerializer.deserialize_value(item["arguments"]),
+          result: ContextSerializer.deserialize_value(item["result"])
+        }
+      end.compact
+    end
+
+    private_class_method :deserialize_undo_stack
+  end
+end

data/lib/ruby_reactor/context_serializer.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  # Utility class for handling context serialization and deserialization
+  class ContextSerializer
+    MAX_CONTEXT_SIZE = 512 * 1024 * 1024 # 512MB Redis limit
+    SCHEMA_VERSION = "1.0"
+
+    class << self
+      def serialize(context, job_id: nil, started_at: nil)
+        data = context.serialize_for_retry(job_id: job_id, started_at: started_at)
+        data[:schema_version] = SCHEMA_VERSION
+
+        serialized = JSON.generate(data)
+        validate_size(serialized)
+
+        compress_if_needed(serialized)
+      end
+
+      def deserialize(serialized_data)
+        decompressed = decompress_if_needed(serialized_data)
+        data = JSON.parse(decompressed, symbolize_names: false)
+
+        validate_schema_version(data)
+
+        Context.deserialize_from_retry(data)
+      rescue JSON::ParserError => e
+        raise RubyReactor::Error::DeserializationError, "Failed to parse serialized context: #{e.message}"
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def serialize_value(value)
+        case value
+        when RubyReactor::Success
+          { "_type" => "Success", "value" => serialize_value(value.value) }
+        when RubyReactor::Failure
+          { "_type" => "Failure", "error" => serialize_value(value.error), "retryable" => value.retryable }
+        when RubyReactor::Context
+          { "_type" => "Context", "value" => value.serialize_for_retry }
+        when Time
+          { "_type" => "Time", "value" => value.iso8601 }
+        when BigDecimal
+          { "_type" => "BigDecimal", "value" => value.to_s("F") }
+        when Rational
+          { "_type" => "Rational", "numerator" => value.numerator, "denominator" => value.denominator }
+        when Date
+          { "_type" => "Date", "value" => value.iso8601 }
+        when DateTime
+          { "_type" => "DateTime", "value" => value.iso8601 }
+        when Complex
+          { "_type" => "Complex", "real" => value.real, "imag" => value.imag }
+        when Range
+          { "_type" => "Range", "begin" => serialize_value(value.begin), "end" => serialize_value(value.end),
+            "exclude_end" => value.exclude_end? }
+        when Regexp
+          { "_type" => "Regexp", "source" => value.source, "options" => value.options }
+        when ->(v) { v.respond_to?(:to_global_id) }
+          { "_type" => "GlobalID", "gid" => value.to_global_id.to_s }
+        when RubyReactor::Template::Element
+          { "_type" => "Template::Element", "map_name" => value.map_name.to_s, "path" => value.path }
+        when RubyReactor::Template::Input
+          { "_type" => "Template::Input", "name" => value.name.to_s, "path" => value.path }
+        when RubyReactor::Template::Value
+          # Actually Template::Value holds a raw value. We should probably just serialize the raw value if possible,
+          # or keep it as a template if we need to distinguish.
+          # But wait, Template::Value is used to wrap raw values in arguments.
+          # If we serialize it, we should probably deserialize it back to Template::Value.
+          { "_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 Hash
+          value.transform_keys(&:to_s).transform_values { |v| serialize_value(v) }
+        when Array
+          value.map { |v| serialize_value(v) }
+        else
+          value
+        end
+      end
+
+      def deserialize_value(value)
+        case value
+        when Hash
+          if value.key?("_type")
+            # Special serialized types (Time, BigDecimal, etc.)
+            case value["_type"]
+            when "Success"
+              RubyReactor::Success(deserialize_value(value["value"]))
+            when "Failure"
+              RubyReactor::Failure(deserialize_value(value["error"]), retryable: value["retryable"])
+            when "Context"
+              Context.deserialize_from_retry(value["value"])
+            when "Time"
+              Time.iso8601(value["value"])
+            when "BigDecimal"
+              BigDecimal(value["value"])
+            when "Rational"
+              Rational(value["numerator"], value["denominator"])
+            when "Date"
+              Date.iso8601(value["value"])
+            when "DateTime"
+              DateTime.iso8601(value["value"])
+            when "Complex"
+              Complex(value["real"], value["imag"])
+            when "Range"
+              Range.new(deserialize_value(value["begin"]), deserialize_value(value["end"]), value["exclude_end"])
+            when "Regexp"
+              Regexp.new(value["source"], value["options"])
+            when "GlobalID"
+              GlobalID::Locator.locate(value["gid"])
+            when "Template::Element"
+              RubyReactor::Template::Element.new(value["map_name"], value["path"])
+            when "Template::Input"
+              RubyReactor::Template::Input.new(value["name"], value["path"])
+            when "Template::Value"
+              RubyReactor::Template::Value.new(deserialize_value(value["value"]))
+            when "Template::Result"
+              RubyReactor::Template::Result.new(value["step_name"], value["path"])
+            else
+              value
+            end
+          else
+            # Regular hash - symbolize all keys recursively
+            value.transform_keys(&:to_sym).transform_values { |v| deserialize_value(v) }
+          end
+        when Array
+          value.map { |v| deserialize_value(v) }
+        else
+          value
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      private
+
+      def validate_size(data)
+        size = data.bytesize
+        return if size <= MAX_CONTEXT_SIZE
+
+        raise RubyReactor::Error::ContextTooLargeError,
+              "Context size #{size} bytes exceeds maximum allowed size of #{MAX_CONTEXT_SIZE} bytes"
+      end
+
+      def compress_if_needed(data)
+        # For now, return uncompressed. Compression can be added later if needed
+        data
+      end
+
+      def decompress_if_needed(data)
+        # For now, assume uncompressed. Decompression logic can be added later
+        data
+      end
+
+      def validate_schema_version(data)
+        version = data["schema_version"]
+        return if version == SCHEMA_VERSION
+
+        # For now, only support exact version match
+        # Future versions could handle migration
+        raise RubyReactor::Error::SchemaVersionError,
+              "Unsupported schema version: #{version}. Expected: #{SCHEMA_VERSION}"
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dependency_graph.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class DependencyGraph
+    def initialize
+      @nodes = {}
+      @edges = {}
+      @dependencies = {} # Store dependencies for each step
+      @completed = Set.new
+    end
+
+    def add_step(step_config)
+      step_name = step_config.name
+      @nodes[step_name] = step_config
+      @edges[step_name] = Set.new
+
+      # Calculate and store dependencies
+      dependencies = []
+
+      # Add dependencies from argument sources
+      step_config.arguments.each_value do |arg_config|
+        source = arg_config[:source]
+        if source.is_a?(RubyReactor::Template::Result)
+          dependencies << source.step_name
+          add_dependency(step_name, source.step_name)
+        end
+      end
+
+      # Add explicit dependencies
+      step_config.dependencies.each do |dep_step|
+        dependencies << dep_step
+        add_dependency(step_name, dep_step)
+      end
+
+      @dependencies[step_name] = dependencies.uniq
+    end
+
+    def add_dependency(step_name, dependency_name)
+      @edges[dependency_name] ||= Set.new
+      @edges[dependency_name] << step_name
+    end
+
+    def ready_steps
+      ready = []
+      @nodes.each do |step_name, step_config|
+        next if @completed.include?(step_name)
+
+        # Check if all dependencies are completed
+        dependencies = @dependencies[step_name] || []
+        ready << step_config if dependencies.all? { |dep| @completed.include?(dep) }
+      end
+      ready
+    end
+
+    def complete_step(step_name)
+      @completed << step_name
+    end
+
+    def has_cycles?
+      visited = Set.new
+      rec_stack = Set.new
+
+      @nodes.each_key do |node|
+        next if visited.include?(node)
+        return true if cycle_detected?(node, visited, rec_stack)
+      end
+
+      false
+    end
+
+    def topological_sort
+      return [] if has_cycles?
+
+      visited = Set.new
+      stack = []
+
+      @nodes.each_key do |node|
+        next if visited.include?(node)
+
+        topological_sort_util(node, visited, stack)
+      end
+
+      stack.reverse.map { |name| @nodes[name] }
+    end
+
+    def all_completed?
+      @completed.size == @nodes.size
+    end
+
+    def pending_steps
+      @nodes.keys - @completed.to_a
+    end
+
+    def topological_sort_util(node, visited, stack)
+      visited << node
+
+      dependents = @edges[node] || Set.new
+      dependents.each do |dependent|
+        next if visited.include?(dependent)
+
+        topological_sort_util(dependent, visited, stack)
+      end
+
+      stack << node
+    end
+
+    private
+
+    def cycle_detected?(node, visited, rec_stack)
+      visited << node
+      rec_stack << node
+
+      dependents = @edges[node] || Set.new
+      dependents.each do |dependent|
+        if !visited.include?(dependent)
+          return true if cycle_detected?(dependent, visited, rec_stack)
+        elsif rec_stack.include?(dependent)
+          return true
+        end
+      end
+
+      rec_stack.delete(node)
+      false
+    end
+  end
+end

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class ComposeBuilder
+      include RubyReactor::Dsl::TemplateHelpers
+
+      attr_accessor :name, :composed_reactor_class, :argument_mappings
+
+      def initialize(name, composed_reactor_class = nil, reactor = nil, &block)
+        @name = name
+        @composed_reactor_class = composed_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        @reactor = reactor
+        @argument_mappings = {}
+        @async = false
+        @retry_config = {}
+      end
+
+      def argument(composed_input_name, source)
+        @argument_mappings[composed_input_name] = source
+      end
+
+      def async(async = true)
+        @async = async
+      end
+
+      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
+        @retry_config = {
+          max_attempts: max_attempts,
+          backoff: backoff,
+          base_delay: base_delay
+        }
+      end
+
+      def build
+        dependencies = extract_dependencies_from_mappings
+
+        step_config = {
+          name: @name,
+          impl: RubyReactor::Step::ComposeStep,
+          arguments: {
+            composed_reactor_class: { source: RubyReactor::Template::Value.new(@composed_reactor_class) },
+            argument_mappings: { source: RubyReactor::Template::Value.new(@argument_mappings) }
+          },
+          run_block: nil,
+          compensate_block: nil,
+          undo_block: nil,
+          conditions: [],
+          guards: [],
+          dependencies: dependencies,
+          args_validator: nil,
+          output_validator: nil,
+          async: @async,
+          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+        }
+
+        RubyReactor::Dsl::StepConfig.new(step_config)
+      end
+
+      # Delegate step definition methods to the composed reactor class
+      def step(name, &block)
+        ensure_composed_reactor_class!
+        @composed_reactor_class.step(name, &block)
+      end
+
+      def compose(name, reactor_class = nil, &block)
+        ensure_composed_reactor_class!
+        @composed_reactor_class.compose(name, reactor_class, &block)
+      end
+
+      private
+
+      def ensure_composed_reactor_class!
+        raise ArgumentError, "No block provided for inline compose" unless @composed_reactor_class
+      end
+
+      def extract_dependencies_from_mappings
+        dependencies = []
+        @argument_mappings.each_value do |source|
+          dependencies << source.step_name if source.is_a?(RubyReactor::Template::Result)
+        end
+        dependencies.uniq
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/map_builder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class MapBuilder
+      include RubyReactor::Dsl::TemplateHelpers
+
+      attr_accessor :name, :mapped_reactor_class, :argument_mappings, :source_enumerable
+
+      def initialize(name, mapped_reactor_class = nil, reactor = nil, &block)
+        @name = name
+        @mapped_reactor_class = mapped_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        @reactor = reactor
+        @argument_mappings = {}
+        @async = false
+        @strict_ordering = true
+        @batch_size = nil
+        @source_enumerable = nil
+        @collect_block = nil
+        @fail_fast = true # Default: stop on first error
+      end
+
+      def argument(mapped_input_name, source)
+        @argument_mappings[mapped_input_name] = source
+      end
+
+      def source(enumerable)
+        @source_enumerable = enumerable
+      end
+
+      def async(async = true, batch_size: nil)
+        @async = async
+        @batch_size = batch_size if batch_size
+      end
+
+      def strict_ordering(enabled = true)
+        @strict_ordering = enabled
+      end
+
+      def batch_size(size)
+        @batch_size = size
+      end
+
+      def collect(&block)
+        @collect_block = block
+      end
+
+      def fail_fast(enabled = true)
+        @fail_fast = enabled
+      end
+
+      def build
+        dependencies = extract_dependencies_from_mappings
+        dependencies << @source_enumerable.step_name if @source_enumerable.is_a?(RubyReactor::Template::Result)
+
+        RubyReactor::Dsl::StepConfig.new(build_step_config(dependencies))
+      end
+
+      # Delegate step definition methods to the mapped reactor class
+      def step(name, &block)
+        ensure_mapped_reactor_class!
+        @mapped_reactor_class.step(name, &block)
+      end
+
+      def returns(step_name)
+        ensure_mapped_reactor_class!
+        @mapped_reactor_class.returns(step_name)
+      end
+      alias return returns
+
+      private
+
+      def ensure_mapped_reactor_class!
+        raise ArgumentError, "No block provided for inline map" unless @mapped_reactor_class
+      end
+
+      def build_step_config(dependencies)
+        {
+          name: @name,
+          impl: RubyReactor::Step::MapStep,
+          arguments: {
+            mapped_reactor_class: { source: RubyReactor::Template::Value.new(@mapped_reactor_class) },
+            argument_mappings: { source: RubyReactor::Template::Value.new(@argument_mappings) },
+            source: { source: @source_enumerable },
+            strict_ordering: { source: RubyReactor::Template::Value.new(@strict_ordering) },
+            batch_size: { source: RubyReactor::Template::Value.new(@batch_size) },
+            collect_block: { source: RubyReactor::Template::Value.new(@collect_block) },
+            fail_fast: { source: RubyReactor::Template::Value.new(@fail_fast) },
+            async: { source: RubyReactor::Template::Value.new(@async) }
+          },
+          run_block: nil,
+          compensate_block: nil,
+          undo_block: nil,
+          conditions: [],
+          guards: [],
+          dependencies: dependencies.uniq,
+          args_validator: nil,
+          output_validator: nil,
+          async: false # MapStep handles async internally via run_async
+        }
+      end
+
+      def extract_dependencies_from_mappings
+        dependencies = []
+        @argument_mappings.each_value do |source|
+          dependencies << source.step_name if source.is_a?(RubyReactor::Template::Result)
+        end
+        dependencies
+      end
+    end
+  end
+end