rapidflow 0.1.0 → 0.2.0

data/scripts/benchmark/simulated_data_processing.rb

@@ -109,9 +109,9 @@ def process_data_synchronously(urls)
   results
 end
 
-# Solution 2: Rapidflow concurrent processing
+# Solution 2: RapidFlow concurrent processing
 def process_data_with_rapidflow(urls, workers: 4)
-  belt = Rapidflow::Batch.build do
+  belt = RapidFlow::Batch.build do
     stage ->(url) { DataProcessor.fetch_html(url) }, workers: workers # Station 1: Fetch HTML
     stage ->(html) { DataProcessor.parse_data(html) }, workers: workers # Station 2: Parse data
     stage ->(data) { DataProcessor.fetch_other_data(data) }, workers: workers # Station 3: Fetch other data
@@ -126,7 +126,7 @@ end
 # Run benchmark
 def run_benchmark(url_count: 50, workers: 4)
   puts "=" * 80
-  puts "Rapidflow Data Processing Benchmark"
+  puts "RapidFlow Data Processing Benchmark"
   puts "=" * 80
   puts
   puts "Configuration:"
@@ -163,7 +163,7 @@ def run_benchmark(url_count: 50, workers: 4)
   puts "Results: #{sync_success} successful, #{sync_failed} failed"
   puts
 
-  # Benchmark Rapidflow
+  # Benchmark RapidFlow
   puts "-" * 80
   puts "2. RAPIDFLOW CONCURRENT PROCESSING"
   puts "-" * 80
@@ -172,7 +172,7 @@ def run_benchmark(url_count: 50, workers: 4)
   rapidflow_results = nil
 
   Benchmark.bm(30) do |x|
-    rapidflow_time = x.report("Rapidflow (#{workers} workers):") do
+    rapidflow_time = x.report("RapidFlow (#{workers} workers):") do
       rapidflow_results = process_data_with_rapidflow(urls, workers: workers)
     end
   end
@@ -197,7 +197,7 @@ def run_benchmark(url_count: 50, workers: 4)
   puts "=" * 80
   puts
   puts "Synchronous time:     #{sync_real_time.round(2)}s"
-  puts "Rapidflow time:       #{rapidflow_real_time.round(2)}s"
+  puts "RapidFlow time:       #{rapidflow_real_time.round(2)}s"
   puts
   puts "Speedup:              #{speedup.round(2)}x faster"
   puts "Time saved:           #{time_saved.round(2)}s"

data/sig/rapidflow.rbs

@@ -1,4 +1,4 @@
-module Rapidflow
+module RapidFlow
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
 end

data/test/rapidflow/batch/config_error_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "test_helper"
+
+module RapidFlow
+  class BatchConfigErrorTest < Minitest::Test
+    def test_no_stages_with_build
+      error = assert_raises(RapidFlow::ConfigError) do
+        Batch.build do
+          # no stages
+        end
+      end
+
+      assert_equal "Unable to start the batch without any stages", error.message
+    end
+
+    def test_no_stages_batch_start
+      error = assert_raises(RapidFlow::ConfigError) do
+        batch = Batch.new
+        batch.start
+      end
+
+      assert_equal "Unable to start the batch without any stages", error.message
+    end
+
+    def test_invalid_worker_count
+      [
+        -3,
+        0,
+        1.5,
+        'foo',
+        :bar
+      ].each do |invalid_worker_count|
+        error = assert_raises(RapidFlow::ConfigError, "Expected to raise exception for '#{invalid_worker_count}'") do
+          Batch.new({ fn: ->(data) { data.upcase }, workers: invalid_worker_count })
+        end
+
+        assert_equal "Worker count should be a positive number for stage", error.message
+      end
+    end
+  end
+end
+
+

data/test/rapidflow/batch/error_handling_test.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+require "test_helper"
+
+module RapidFlow
+  class BatchErrorHandlingTest < Minitest::Test
+    def test_error_handling_captures_exceptions
+      batch = Batch.build do
+        stage ->(data) {
+          raise "Error in stage 1" if data == "bad"
+          data
+        }
+        stage ->(data) { data.upcase }
+      end
+
+      batch.push("good")
+      batch.push("bad")
+
+      results = batch.results
+
+      assert_equal 2, results.length
+
+      # Good result should complete both stages
+      assert_equal "GOOD", results[0][0]
+      assert_nil results[0][1]
+
+      # Bad result should have error from stage 1 and not be processed by stage 2
+      assert_equal "bad", results[1][0] # Original data preserved
+      assert_instance_of RuntimeError, results[1][1]
+      assert_equal "Error in stage 1", results[1][1].message
+    end
+
+    def test_error_in_middle_stage
+      batch = Batch.build do
+        stage ->(data) { data.upcase }
+        stage ->(data) {
+          raise "Error in stage 2" if data == "BAD"
+          data
+        }
+        stage ->(data) { data + "!" }
+      end
+
+      batch.push("good")
+      batch.push("bad")
+      batch.push("also_good")
+
+      results = batch.results
+
+      assert_equal 3, results.length
+      assert_equal ["GOOD!", nil], results[0]
+      assert_equal ["BAD", results[1][1]], [results[1][0], results[1][1]]
+      assert_equal "Error in stage 2", results[1][1].message
+      assert_equal ["ALSO_GOOD!", nil], results[2]
+    end
+
+    def test_error_in_last_stage
+      batch = Batch.build do
+        stage ->(data) { data.upcase }
+        stage ->(data) {
+          raise "Error in final stage" if data == "BAD"
+          data
+        }
+      end
+
+      batch.push("good")
+      batch.push("bad")
+
+      results = batch.results
+
+      assert_equal 2, results.length
+      assert_equal ["GOOD", nil], results[0]
+      assert_equal ["BAD", results[1][1]], [results[1][0], results[1][1]]
+      assert_equal "Error in final stage", results[1][1].message
+    end
+
+    def test_multiple_errors_in_sequence
+      batch = Batch.build do
+        stage ->(data) {
+          raise "Error at #{data}" if data.start_with?("bad")
+          data
+        }
+      end
+
+      batch.push("good1")
+      batch.push("bad1")
+      batch.push("bad2")
+      batch.push("good2")
+
+      results = batch.results
+
+      assert_equal 4, results.length
+      assert_equal ["good1", nil], results[0]
+      assert_instance_of RuntimeError, results[1][1]
+      assert_instance_of RuntimeError, results[2][1]
+      assert_equal ["good2", nil], results[3]
+    end
+
+    def test_exception_types_preserved
+      batch = Batch.build do
+        stage ->(data) {
+          case data
+          when "argument_error"
+            raise ArgumentError, "Bad argument"
+          when "runtime_error"
+            raise "Runtime problem"
+          when "custom_error"
+            raise StandardError, "Custom error"
+          else
+            data
+          end
+        }
+      end
+
+      batch.push("good")
+      batch.push("argument_error")
+      batch.push("runtime_error")
+      batch.push("custom_error")
+
+      results = batch.results
+
+      assert_equal 4, results.length
+      assert_equal ["good", nil], results[0]
+      assert_instance_of ArgumentError, results[1][1]
+      assert_instance_of RuntimeError, results[2][1]
+      assert_instance_of StandardError, results[3][1]
+    end
+
+    def test_all_items_fail
+      batch = Batch.build do
+        stage ->(data) { raise "Always fails" }
+      end
+
+      5.times { |i| batch.push(i) }
+
+      results = batch.results
+
+      assert_equal 5, results.length
+      results.each do |result, error|
+        assert_instance_of RuntimeError, error
+        assert_equal "Always fails", error.message
+      end
+    end
+
+    def test_no_method_error_in_first_lamda_function
+      batch = Batch.build do
+        # invalid stage - calling invalid method
+        stage ->(data) { data.foobar }
+
+        # valid stage
+        stage ->(data) { data.upcase }
+
+        # valid stage
+        stage ->(data) { data + '!' }
+      end
+
+      batch.push("hello")
+
+      results = batch.results
+
+      assert_equal 1, results.length
+      assert_equal "hello", results.first[0] # preserved the original input as the error happened in the first stage
+      assert_instance_of NoMethodError, results.first[1]
+
+      expected_error_message = case RUBY_VERSION
+                               when /^3.4/
+                                 "undefined method 'foobar' for an instance of String"
+                               when /^3.3/
+                                 "undefined method `foobar' for an instance of String"
+                               when /^3.2/
+                                 "undefined method `foobar' for \"hello\":String"
+                               else
+                                 raise "Unexpected ruby version: #{RUBY_VERSION}"
+                               end
+
+      assert_equal expected_error_message, results.first[1].message
+    end
+
+    def test_no_method_error_in_mid_lamda_function
+      batch = Batch.build do
+        # valid stage
+        stage ->(data) { data.upcase }
+
+        # invalid stage - calling invalid method
+        stage ->(data) { data.foobar }
+
+        # valid stage
+        stage ->(data) { data + '!' }
+      end
+
+      batch.push("hello")
+
+      results = batch.results
+
+      assert_equal 1, results.length
+      assert_equal "HELLO", results.first[0]
+      assert_instance_of NoMethodError, results.first[1]
+
+      expected_error_message = case RUBY_VERSION
+                               when /^3.4/
+                                 "undefined method 'foobar' for an instance of String"
+                               when /^3.3/
+                                 "undefined method `foobar' for an instance of String"
+                               when /^3.2/
+                                 "undefined method `foobar' for \"HELLO\":String"
+                               else
+                                 raise "Unexpected ruby version: #{RUBY_VERSION}"
+                               end
+
+      assert_equal expected_error_message, results.first[1].message
+    end
+  end
+end