rapidflow 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa80e7ea5e1d6b4589b86ac1836fd1a6092741d5b85843d846d6004c287636b7
-  data.tar.gz: bda98d315cae3fa4641ef4e17105b3b2d6e8fc3f3e564297c63a3e7bfbd57005
+  metadata.gz: 29bd4bb0143b3647bad175cce56fe0a3b519114c5f951dddb853d2ea233f07ce
+  data.tar.gz: 95453103f015ff84017a6f9bc1b99f606a7864e6517d523297f544711f2b8bc2
 SHA512:
-  metadata.gz: 64dc1239e9aa51a0ceb5dd0745b14573a31a6cede322793088fad09b0c963ec30867e4e7cefacbc0ab45c33d4ff9faa58d8cbab3d039cbaf6e8ff2c9082899af
-  data.tar.gz: b7230b85fa7eeecb915bd389a293d1664909d5bef3336a009750b52366fe0b019e067cffb84387a819cedc44560ef8540b7e90766e1e1de2a240bdb637cde37a
+  metadata.gz: 05ac1a3b0ca195158082ba1abe3b698b80ccbbbc476d330b69167178223f39f93d4c3d16572472cceb7c4a910eecd06d765cbfab7ff7b60220fe1b82e8476eff
+  data.tar.gz: 7b7934103e0055302043c5cc3a17000f42f3d6e4fa4d405a3106239ee64c486d6c807963bf9407b442b1106b728993128824372eeece399476f986b668bf3080

data/CHANGELOG.md

@@ -5,7 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.0] - 2025.11.11
+
+### Added
+
+- Validation for `workers` count. Worker count should be a positive integer.
+
+### Changed
+
+- Rename module `Rapidflow` to `RapidFlow`.
+- Move custom error classes from `RapidFlow::Batch` class under to `RapidFlow` module.
 
 ## [0.1.0] - 2025.11.01
 

data/README.md

@@ -1,20 +1,20 @@
-# 🌊 Rapidflow
+# 🌊 RapidFlow
 
 ⚙️💎➡️📦💨🔁🌊
 > A Ruby library for concurrent batch data processing through lightweight, composable flows.
 
+[![Gem Version](https://badge.fury.io/rb/rapidflow.svg)](https://badge.fury.io/rb/rapidflow)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-> **⚠️ Early Development Warning**: This library is at a very early stage of development. The interfaces and APIs 
-> may change without backward compatibility guarantees. Use in production at your own risk.
+> Note: ⚠️ This library is at a very early stage of development. The interfaces and APIs 
+> may change without backward compatibility guarantees in minor versions (0.[minor version].[patch]).
 
-Rapidflow is a lightweight, concurrent pipeline processor for Ruby that transforms data through multiple stages like 
-items moving through stages in a rapid flow. Perfect for I/O-bound operations like web scraping, API calls, 
-and data processing.
+RapidFlow is a lightweight, concurrent pipeline processor for Ruby that transforms data through multiple stages using Ruby Threads. 
+Perfect for I/O-bound operations like web scraping, API calls, and data processing.
 
 ## Features
 
-- 🚀 **Concurrent Processing** - Multiple workers per stage process items in parallel
+- 🚀 **Concurrent Processing** - Multiple workers per stage process items concurrently
 - 🔄 **True Pipelining** - Different stages process different items simultaneously
 - 📦 **Order Preservation** - Results returned in the same order items were pushed
 - 🛡️ **Error Handling** - Captures exceptions without stopping the flow
@@ -54,7 +54,7 @@ Create a batch instance.
 require 'rapidflow'
 
 # Create a 3-stage processing batch. Workers can be configured per stage basis or will use the default amount if omitted.
-scraper = Rapidflow::Batch.build do
+scraper = RapidFlow::Batch.build do
   stage ->(url) { fetch_html(url) }, workers: 8 # Stage 1: Fetch HTML
   stage ->(html) { parse_data(html) }, workers: 2 # Stage 2: Parse data
   stage ->(data) { save_to_db(data) } # Stage 3: Save to a database
@@ -64,7 +64,7 @@ end
 Alternatively, you can also initialize the batch with the following syntax:
 
 ```ruby
-batch = Rapidflow::Batch.new(
+batch = RapidFlow::Batch.new(
   { fn: ->(url) { fetch_html(url) }, workers: 8 }, # Stage 1: Fetch HTML.
   { fn: ->(html) { parse_data(html) }, workers: 2 }, # Stage 2: Parse data
   { fn: ->(data) { save_to_db(data) } } # Stage 3: Save to database
@@ -88,8 +88,7 @@ Note that Once you call `Batch#results`, it will block the batch until all proce
 longer push items to the batch instance.
 
 The results are returned in the same order as the original items were pushed. Each result is an array of
-`[data, error]`. If an error happened for an item during processing, `error` will be present with the Error instance. 
-Otherwise `data` represent the final data that was successfully processed and `error` will be `nil`.
+`[data, error]`. No error means the item successfully were processed through the stages.
 
 ```ruby
 results.each_with_index do |(data, error), index|
@@ -101,12 +100,58 @@ results.each_with_index do |(data, error), index|
 end
 ```
 
+## Error Handling
+
+RapidFlow continues running even when errors occur, instead of stopping the entire pipeline.
+
+When an item encounters an error at any stage, RapidFlow captures that error and moves the item to the 
+final results—skipping all remaining stages for that particular item.
+
+Each result comes as a pair: `[data, error]`.
+- If processing failed: `error` contains the Error instance, and `data` holds whatever transformed data existed 
+from the last successful stage (or original input data if the error occurred at the first stage).
+- If processing succeeded: `data` contains the fully processed result, and `error` is `nil`.
+
+```ruby
+batch = RapidFlow::Batch.new(
+  { fn: ->(url) { HTTP.get(url).body } }, # May raise network errors
+  { fn: ->(body) { JSON.parse(body) } } # May raise JSON parse errors
+)
+
+urls.each { |url| batch.push(url) }
+results = batch.results
+
+results.each_with_index do |(data, error), index|
+  if error
+    # Original input if error happened at first stage. Otherwise, transformed data from the previous stage before the error happened
+    # It is preserved in 'data' for debugging if needed.
+    puts "Data state before error #{data}"
+    
+    puts "Failed to process #{urls[index]}: #{error.class} - #{error.message}"
+    # Log error, retry, or handle gracefully
+    
+    puts "Error backtrace: "
+    pp error.backtrace
+    # As any Exception contains the backtrace(https://docs.ruby-lang.org/en/master/Exception.html#method-i-backtrace),
+    # for further debugging, you can look into backtrace.
+  else
+    puts "Success: #{data}"
+  end
+end
+```
+
+**Error behavior:**
+- Exceptions are caught and returned with results
+- The transformed data from the previous stage is preserved when an error occurs
+- Errors in early stages skip remaining stages until they reach the result queue
+- Other items continue processing (errors don't stop the batch)
+
 ## Usage Examples
 
 ### Web Scraping Pipeline
 
 ```ruby
-scraper = Rapidflow::Batch.build do
+scraper = RapidFlow::Batch.build do
   stage ->(url) {
     # Fetch HTML (may take 1-2 seconds per URL)
     HTTP.get(url).to_s
@@ -136,7 +181,7 @@ results = scraper.results
 ### Image Processing Pipeline
 
 ```ruby
-processor = Rapidflow::Batch.build do
+processor = RapidFlow::Batch.build do
   stage ->(path) { MiniMagick::Image.open(path) }, workers: 4 # Stage 1: Load image
   stage ->(img) { img.resize('800x600'); img }, workers: 4 # Stage 2: Resize
   stage ->(img) { img.colorspace('Gray'); img }, workers: 4 # Stage 3: Convert to grayscale
@@ -152,7 +197,7 @@ puts "Processed #{results.count { |_, err| err.nil? }} images successfully"
 ### API Data Enrichment
 
 ```ruby
-enricher = Rapidflow::Batch.build do
+enricher = RapidFlow::Batch.build do
   stage ->(user_id) {
     # Fetch user data from API
     api_client.get("/users/#{user_id}").parse
@@ -181,7 +226,7 @@ enriched_users = enricher.results
 
 ```ruby
 # Extract, Transform, Load
-etl = Rapidflow::Batch.build do
+etl = RapidFlow::Batch.build do
   stage ->(filename) {
     # Extract: Read CSV file
     CSV.read(filename, headers: true).map(&:to_h)
@@ -211,45 +256,15 @@ puts "Loaded #{total_records} records"
 ```ruby
 # Sometimes you just need parallel processing without multiple stages
 # Fetch 20 URLs concurrently
-fetcher = Rapidflow::Batch.new({ fn: ->(url) { HTTP.get(url).body }, workers: 20 })
+fetcher = RapidFlow::Batch.new({ fn: ->(url) { HTTP.get(url).body }, workers: 20 })
 
 urls.each { |url| fetcher.push(url) }
 pages = fetcher.results
 ```
 
-## Error Handling
-
-Rapidflow captures exceptions without stopping the pipeline:
-
-```ruby
-batch = Rapidflow::Batch.new(
-  { fn: ->(url) { HTTP.get(url).body } }, # May raise network errors
-  { fn: ->(body) { JSON.parse(body) } } # May raise JSON parse errors
-)
-
-urls.each { |url| batch.push(url) }
-results = batch.results
-
-results.each_with_index do |(data, error), index|
-  if error
-    # Original input is preserved in 'data' for debugging
-    puts "Failed to process #{urls[index]}: #{error.class} - #{error.message}"
-    # Log error, retry, or handle gracefully
-  else
-    puts "Success: #{data}"
-  end
-end
-```
-
-**Error behavior:**
-- Exceptions are caught and returned with results
-- The original data is preserved when an error occurs
-- Errors in early stages passed down to remaining stages until they reach the result queue
-- Other items continue processing (errors don't stop the batch)
-
 ## Architecture
 
-Rapidflow uses a multi-stage pipeline architecture with concurrent workers at each stage.
+RapidFlow uses a multi-stage pipeline architecture with concurrent workers at each stage.
 
 ### Pipeline Flow
 
@@ -353,10 +368,10 @@ Choose based on your workload:
 
 ```ruby
 # High I/O workload - many workers
-Rapidflow::Batch.new({ fn: lambda1, workers: 100 }, { fn: lambda2, workers: 50 })
+RapidFlow::Batch.new({ fn: lambda1, workers: 100 }, { fn: lambda2, workers: 50 })
 
 # CPU-intensive - fewer workers
-Rapidflow::Batch.new({ fn: lambda1, workers: 2 }, { fn: lambda2, workers: 2 })
+RapidFlow::Batch.new({ fn: lambda1, workers: 2 }, { fn: lambda2, workers: 2 })
 ```
 
 ### Balancing Workers for Stages
@@ -364,8 +379,8 @@ Rapidflow::Batch.new({ fn: lambda1, workers: 2 }, { fn: lambda2, workers: 2 })
 For the best throughput, workers should be assigned based on the I/O-bound workload of each stage:
 
 ```ruby
-# ❌ Same number of workers even though stages have different I/O duration
-Rapidflow::Batch.build do
+# ❌ Same number of workers even though stages have different I/O load
+RapidFlow::Batch.build do
   stage ->(x) { sleep(10); x }, workers: 4 # 10 seconds - SLOW! (Assume a heavy or long-running I/O task)
   stage ->(x) { sleep(0.1); x }, workers: 4 # 0.1 seconds - fast
   stage ->(x) { sleep(0.1); x }, workers: 4 # 0.1 seconds - fast
@@ -373,7 +388,7 @@ Rapidflow::Batch.build do
 end
 
 # ✅ Balanced - workers are assigned based of I/O load
-Rapidflow::Batch.build do
+RapidFlow::Batch.build do
   stage ->(x) { sleep(10); x }, workers: 16 # 10 seconds - SLOW!
   stage ->(x) { sleep(0.1); x }, workers: 2 # 0.1 seconds - fast
   stage ->(x) { sleep(0.1); x }, workers: 2 # 0.1 seconds - fast
@@ -383,7 +398,7 @@ end
 
 ### Memory Considerations
 
-- Each queue can grow unbounded - don't push millions of items without consuming results
+- Each queue can grow unbounded—don't push millions of items without consuming results
 - Workers hold items in memory during processing
 - Memory usage ≈ (items in queues + items being processed) × item size
 
@@ -403,11 +418,11 @@ end
 - Share mutable state between workers without synchronization
 - Push millions of items without processing results (memory issue)
 - Create dependencies between items (order of execution not guaranteed)
-- Nest Rapidflow instances (use a single multi-stage batch instead)
+- Nest RapidFlow instances (use a single multi-stage batch instead)
 
 ## Comparison with Alternatives
 
-| Feature                  | Rapidflow | Thread Pool   | Sidekiq        | Concurrent-Ruby |
+| Feature                  | RapidFlow | Thread Pool   | Sidekiq        | Concurrent-Ruby |
 |--------------------------|-----------|---------------|----------------|-----------------|
 | **Multi-stage pipeline** | ✅        | ❌            | ⚠️ (manual)    | ❌              |
 | **Order preservation**   | ✅        | ❌            | ❌             | ❌              |
@@ -424,13 +439,13 @@ The following result is taken from a benchmark run of [./scripts/benchmark/bench
 ```bash
 /scripts/benchmark$ ruby benchmark_api_request_process_and_storing.rb 40 32
 ================================================================================
-Rapidflow API Request, Process & Store Benchmark
+RapidFlow API Request, Process & Store Benchmark
 ================================================================================
 
 Configuration:
   API: dummyjson.com
   User IDs to process: 1 to 40
-  Workers per stage (Rapidflow): 32
+  Workers per stage (RapidFlow): 32
   Stages: Fetch User → Fetch Product → Merge Data → Save to File
 
 Processing 40 user IDs...
@@ -447,7 +462,7 @@ Results: 40 successful, 0 failed
 2. RAPIDFLOW CONCURRENT PROCESSING
 --------------------------------------------------------------------------------
                                      user     system      total        real
-Rapidflow (32 workers):          0.217776   0.084002   0.301778 (  0.612455)
+RapidFlow (32 workers):          0.217776   0.084002   0.301778 (  0.612455)
 
 Results: 40 successful, 0 failed
 
@@ -456,7 +471,7 @@ SUMMARY
 ================================================================================
 
 Synchronous time:     13.18s
-Rapidflow time:       0.61s
+RapidFlow time:       0.61s
 
 Speedup:              21.52x faster
 Time saved:           12.57s
@@ -466,7 +481,7 @@ Performance gain:     2052.1%
 FILE VERIFICATION
 --------------------------------------------------------------------------------
 Synchronous output:   40 files created
-Rapidflow output:     40 files created
+RapidFlow output:     40 files created
 
 Sample output file: data_1.json
   User ID: 1
@@ -481,11 +496,11 @@ PERFORMANCE ANALYSIS
 
 Average time per item:
   Synchronous:  329.51ms
-  Rapidflow:    15.31ms
+  RapidFlow:    15.31ms
 
 Throughput (items/second):
   Synchronous:  3.03 items/sec
-  Rapidflow:    65.31 items/sec
+  RapidFlow:    65.31 items/sec
 ```
 
 ## Development
@@ -505,7 +520,7 @@ to be a safe, welcoming space for collaboration, and contributors are expected t
 
 ## Code of Conduct
 
-Everyone interacting in the Rapidflow project's codebases, issue trackers, chat rooms and mailing lists is expected 
+Everyone interacting in the RapidFlow project's codebases, issue trackers, chat rooms and mailing lists is expected 
 to follow the [code of conduct](https://github.com/sinaru/rapidflow/blob/main/CODE_OF_CONDUCT.md).
 
 ## License

data/lib/rapidflow/batch.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
-module Rapidflow
+module RapidFlow
   class Batch
-    class ConfigError < RuntimeError; end
-    class RunError < RuntimeError; end
-
     # DSL entrypoint
     def self.build(&block)
-      builder = Builder.new
+      builder = BatchBuilder.new
       builder.instance_eval(&block) if block
-      belt = new(*builder.stages)
-      belt.start
-      belt
+      batch = new(*builder.stages)
+      batch.start
+      batch
     end
 
     # Initialize with a list of stage configs: { fn: -> (input) { }, workers: Integer }, ...
@@ -27,13 +24,13 @@ module Rapidflow
       @locked = false
       @locked_mutex = Mutex.new
 
-      # to track if belt is running
+      # to track if batch is running
       @running = false
       @running_mutex = Mutex.new
     end
 
     def start
-      raise ConfigError, "Unable to start the belt without any stages" if @stages.empty?
+      raise RapidFlow::ConfigError, "Unable to start the batch without any stages" if @stages.empty?
 
       @stages.each(&:start)
       mark_run!
@@ -57,19 +54,6 @@ module Rapidflow
 
     private
 
-    # DSL builder
-    class Builder
-      attr_reader :stages
-
-      def initialize
-        @stages = []
-      end
-
-      def stage(lambda_fn, workers: 4)
-        @stages << { fn: lambda_fn, workers: workers }
-      end
-    end
-
     def build_stages
       stages = []
       @lambdas.each_with_index do |lambda_fn, stage_index|
@@ -99,13 +83,13 @@ module Rapidflow
 
     def ensure_not_finalized!
       @locked_mutex.synchronize do
-        raise RunError, "Cannot push to a locked belt when results are requested" if @locked
+        raise RapidFlow::RunError, "Cannot push to a locked batch when results are requested" if @locked
       end
     end
 
     def ensure_running!
       @running_mutex.synchronize do
-        raise RunError, "Batch has not started" unless @running
+        raise RapidFlow::RunError, "Batch has not started" unless @running
       end
     end
 

data/lib/rapidflow/batch_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RapidFlow
+  # DSL builder
+  class BatchBuilder
+    attr_reader :stages
+
+    def initialize
+      @stages = []
+    end
+
+    def stage(lambda_fn, workers: 4)
+      @stages << { fn: lambda_fn, workers: workers }
+    end
+  end
+end

data/lib/rapidflow/counter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Rapidflow
+module RapidFlow
   # Tracks item indices for ordering
   class Counter
     def initialize

data/lib/rapidflow/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RapidFlow
+  # Error class to use when the client setup code is invalid.
+  class ConfigError < RuntimeError; end
+  class RunError < RuntimeError; end
+end

data/lib/rapidflow/pipeline.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Rapidflow
+module RapidFlow
   # Manages the queues and worker coordination
   class Pipeline
     # workers_per_stage can be an Integer (uniform) or an Array per stage

data/lib/rapidflow/stage.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-module Rapidflow
+module RapidFlow
   # Represents a processing stage in the pipeline
   class Stage
     def initialize(stage_index:, lambda_fn:, workers:, is_final:, pipeline:)
+      validate_worker!(workers)
+
       @stage_index = stage_index
       @lambda_fn = lambda_fn
       @workers = workers
@@ -56,5 +58,11 @@ module Rapidflow
       @pipeline.enqueue(@stage_index + 1, work_item)
       @pipeline.decrement_active_workers if @is_final
     end
+
+    def validate_worker!(workers)
+      return if workers.kind_of?(Integer) && workers.positive?
+
+      raise RapidFlow::ConfigError, "Worker count should be a positive number for stage"
+    end
   end
 end

data/lib/rapidflow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Rapidflow
-  VERSION = "0.1.0"
+module RapidFlow
+  VERSION = "0.2.0"
 end

data/lib/rapidflow/work_item.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Rapidflow
+module RapidFlow
   # Represents a work item flowing through the pipeline
   WorkItem = Struct.new('WorkItem', :index, :data, :error) do
     def has_error?

data/lib/rapidflow.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "rapidflow/version"
+require_relative "rapidflow/errors"
 require_relative "rapidflow/counter"
 require_relative "rapidflow/pipeline"
 require_relative "rapidflow/work_item"
 require_relative "rapidflow/stage"
+require_relative "rapidflow/batch_builder"
 require_relative "rapidflow/batch"
 
-module Rapidflow
+module RapidFlow
 end

data/scripts/benchmark/benchmark_api_request_process_and_storing.rb

@@ -82,11 +82,11 @@ def process_data_synchronously(user_ids, output_dir)
   results
 end
 
-# Solution 2: Rapidflow concurrent processing
+# Solution 2: RapidFlow concurrent processing
 def process_data_with_rapidflow(user_ids, output_dir, workers: 8)
   FileUtils.mkdir_p(output_dir)
 
-  belt = Rapidflow::Batch.build do
+  belt = RapidFlow::Batch.build do
     # Stage 1: Fetch user data from API
     stage ->(user_id) {
       ApiClient.fetch_user(user_id)
@@ -119,13 +119,13 @@ end
 # Run benchmark
 def run_benchmark(max_user_id: 30, workers: 8)
   puts "=" * 80
-  puts "Rapidflow API Request, Process & Store Benchmark"
+  puts "RapidFlow API Request, Process & Store Benchmark"
   puts "=" * 80
   puts
   puts "Configuration:"
   puts "  API: dummyjson.com"
   puts "  User IDs to process: 1 to #{max_user_id}"
-  puts "  Workers per stage (Rapidflow): #{workers}"
+  puts "  Workers per stage (RapidFlow): #{workers}"
   puts "  Stages: Fetch User → Fetch Product → Merge Data → Save to File"
   puts
 
@@ -167,7 +167,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
   end
   puts
 
-  # Benchmark Rapidflow
+  # Benchmark RapidFlow
   puts "-" * 80
   puts "2. RAPIDFLOW CONCURRENT PROCESSING"
   puts "-" * 80
@@ -176,7 +176,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
   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(user_ids, "tmp/output_rapidflow", workers: workers)
     end
   end
@@ -210,7 +210,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
   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"
@@ -226,7 +226,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
   rapidflow_files = Dir.glob("tmp/output_rapidflow/data_*.json").length
 
   puts "Synchronous output:   #{sync_files} files created"
-  puts "Rapidflow output:     #{rapidflow_files} files created"
+  puts "RapidFlow output:     #{rapidflow_files} files created"
   puts
 
   # Sample file content verification
@@ -256,7 +256,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
 
   puts "Average time per item:"
   puts "  Synchronous:  #{(avg_time_per_item_sync * 1000).round(2)}ms"
-  puts "  Rapidflow:    #{(avg_time_per_item_rapid * 1000).round(2)}ms"
+  puts "  RapidFlow:    #{(avg_time_per_item_rapid * 1000).round(2)}ms"
   puts
 
   throughput_sync = max_user_id / sync_real_time
@@ -264,7 +264,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
 
   puts "Throughput (items/second):"
   puts "  Synchronous:  #{throughput_sync.round(2)} items/sec"
-  puts "  Rapidflow:    #{throughput_rapid.round(2)} items/sec"
+  puts "  RapidFlow:    #{throughput_rapid.round(2)} items/sec"
   puts
 
   # Cleanup prompt
@@ -273,7 +273,7 @@ def run_benchmark(max_user_id: 30, workers: 8)
   puts "-" * 80
   puts
   puts "Synchronous files: tmp/output_sync/"
-  puts "Rapidflow files:   tmp/output_rapidflow/"
+  puts "RapidFlow files:   tmp/output_rapidflow/"
   puts
   puts "To clean up output directories, run:"
   puts "  rm -rf tmp/output_sync tmp/output_rapidflow"

data/scripts/benchmark/benchmark_images.rb

@@ -89,11 +89,11 @@ def process_images_synchronously(image_paths, output_dir)
   results
 end
 
-# Solution 2: Rapidflow concurrent processing
+# Solution 2: RapidFlow concurrent processing
 def process_images_with_rapidflow(image_paths, output_dir, workers: 4)
   FileUtils.mkdir_p(output_dir)
 
-  belt = Rapidflow::Batch.build do
+  belt = RapidFlow::Batch.build do
     # Stage 1: Load image
     stage ->(path) { ImageProcessor.load_image(path) }, workers: workers
 
@@ -114,7 +114,7 @@ end
 # Run benchmark
 def run_benchmark(sample_image_path, image_count: 50, workers: 4)
   puts "=" * 80
-  puts "Rapidflow Image Processing Benchmark"
+  puts "RapidFlow Image Processing Benchmark"
   puts "=" * 80
   puts
   puts "Configuration:"
@@ -157,7 +157,7 @@ def run_benchmark(sample_image_path, image_count: 50, workers: 4)
   end
   puts
 
-  # Benchmark Rapidflow
+  # Benchmark RapidFlow
   puts "-" * 80
   puts "2. RAPIDFLOW CONCURRENT PROCESSING"
   puts "-" * 80
@@ -166,7 +166,7 @@ def run_benchmark(sample_image_path, image_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_images_with_rapidflow(image_paths, "tmp/output_rapidflow", workers: workers)
     end
   end
@@ -191,7 +191,7 @@ def run_benchmark(sample_image_path, image_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"