simple_flow 0.1.0

data/examples/regression_test/09_pipeline_visualization.txt

@@ -0,0 +1,305 @@
+============================================================
+Direct Pipeline Visualization
+============================================================
+
+Example 1: Simple Pipeline Visualization
+------------------------------------------------------------
+
+Dependency Graph
+============================================================
+
+Dependencies:
+  :validate
+    └─ depends on: (none)
+  :fetch_data
+    └─ depends on: :validate
+  :process_data
+    └─ depends on: :fetch_data
+
+Execution Order (sequential):
+  :validate
+  ↓ :fetch_data
+  ↓ :process_data
+
+Parallel Execution Groups:
+  Group 1:
+    └─ :validate (sequential)
+  Group 2:
+    └─ :fetch_data (sequential)
+  Group 3:
+    └─ :process_data (sequential)
+
+Execution Tree:
+  ├─ :validate
+  ├─ :fetch_data
+  └─ :process_data
+
+
+============================================================
+Example 2: E-commerce Pipeline (Automatic Visualization)
+============================================================
+
+Dependency Graph
+============================================================
+
+Dependencies:
+  :validate_order
+    └─ depends on: (none)
+  :check_inventory
+    └─ depends on: :validate_order
+  :calculate_shipping
+    └─ depends on: :validate_order
+  :calculate_totals
+    └─ depends on: :calculate_shipping, :check_inventory
+  :process_payment
+    └─ depends on: :calculate_totals
+  :reserve_inventory
+    └─ depends on: :process_payment
+  :create_shipment
+    └─ depends on: :reserve_inventory
+  :send_email
+    └─ depends on: :create_shipment
+  :send_sms
+    └─ depends on: :create_shipment
+  :finalize_order
+    └─ depends on: :send_email, :send_sms
+
+Execution Order (sequential):
+  :validate_order
+  ↓ :check_inventory
+  ↓ :calculate_shipping
+  ↓ :calculate_totals
+  ↓ :process_payment
+  ↓ :reserve_inventory
+  ↓ :create_shipment
+  ↓ :send_email
+  ↓ :send_sms
+  ↓ :finalize_order
+
+Parallel Execution Groups:
+  Group 1:
+    └─ :validate_order (sequential)
+  Group 2:
+    ├─ Parallel execution of 2 steps:
+    ├─ :calculate_shipping
+    └─ :check_inventory
+  Group 3:
+    └─ :calculate_totals (sequential)
+  Group 4:
+    └─ :process_payment (sequential)
+  Group 5:
+    └─ :reserve_inventory (sequential)
+  Group 6:
+    └─ :create_shipment (sequential)
+  Group 7:
+    ├─ Parallel execution of 2 steps:
+    ├─ :send_email
+    └─ :send_sms
+  Group 8:
+    └─ :finalize_order (sequential)
+
+Execution Tree:
+  ├─ :validate_order
+  ├─ [Parallel]
+  │  ├─ :calculate_shipping
+  │  └─ :check_inventory
+  ├─ :calculate_totals
+  ├─ :process_payment
+  ├─ :reserve_inventory
+  ├─ :create_shipment
+  ├─ [Parallel]
+  │  ├─ :send_email
+  │  └─ :send_sms
+  └─ :finalize_order
+
+
+============================================================
+Example 3: Execution Plan (Direct from Pipeline)
+============================================================
+
+Execution Plan
+============================================================
+
+Total Steps: 10
+Execution Phases: 8
+
+Phase 1:
+  → Execute :validate_order
+
+Phase 2:
+  ⚡ Execute in parallel:
+     • :calculate_shipping (after :validate_order)
+     • :check_inventory (after :validate_order)
+
+Phase 3:
+  → Execute :calculate_totals
+
+Phase 4:
+  → Execute :process_payment
+
+Phase 5:
+  → Execute :reserve_inventory
+
+Phase 6:
+  → Execute :create_shipment
+
+Phase 7:
+  ⚡ Execute in parallel:
+     • :send_email (after :create_shipment)
+     • :send_sms (after :create_shipment)
+
+Phase 8:
+  → Execute :finalize_order
+
+Performance Estimate:
+  Sequential execution: 10 time units
+  Parallel execution: 8 time units
+  Potential speedup: 1.25x
+
+
+============================================================
+Example 4: Export Formats (Direct from Pipeline)
+============================================================
+
+✓ Exported to Graphviz DOT: pipeline_graph.dot
+  Generate image: dot -Tpng pipeline_graph.dot -o pipeline.png
+
+✓ Exported to Mermaid: pipeline_graph.mmd
+  View at: https://mermaid.live/
+
+✓ Exported to HTML: pipeline_graph.html
+  Open in browser for interactive visualization
+
+
+============================================================
+Example 5: ETL Pipeline Visualization
+============================================================
+
+Execution Plan
+============================================================
+
+Total Steps: 10
+Execution Phases: 5
+
+Phase 1:
+  ⚡ Execute in parallel:
+     • :extract_orders (no dependencies)
+     • :extract_products (no dependencies)
+     • :extract_users (no dependencies)
+
+Phase 2:
+  ⚡ Execute in parallel:
+     • :transform_orders (after :extract_orders)
+     • :transform_products (after :extract_products)
+     • :transform_users (after :extract_users)
+
+Phase 3:
+  ⚡ Execute in parallel:
+     • :aggregate_category_stats (after :transform_products)
+     • :aggregate_user_stats (after :transform_orders, :transform_users)
+
+Phase 4:
+  → Execute :validate_data
+
+Phase 5:
+  → Execute :prepare_output
+
+Performance Estimate:
+  Sequential execution: 10 time units
+  Parallel execution: 5 time units
+  Potential speedup: 2.0x
+
+
+============================================================
+Example 6: Checking Visualization Availability
+============================================================
+
+Named pipeline has dependency graph? true
+Unnamed pipeline has dependency graph? false
+
+Note: Only pipelines with named steps and dependencies can be auto-visualized
+
+
+============================================================
+Example 7: Advanced - Access Dependency Graph
+============================================================
+
+Pipeline dependency information:
+  Total steps: 10
+  Execution phases: 8
+  Parallel groups:
+    Phase 1: validate_order
+    Phase 2: calculate_shipping, check_inventory
+    Phase 3: calculate_totals
+    Phase 4: process_payment
+    Phase 5: reserve_inventory
+    Phase 6: create_shipment
+    Phase 7: send_email, send_sms
+    Phase 8: finalize_order
+
+
+============================================================
+Example 8: Pipeline Structure Comparison
+============================================================
+
+Linear Pipeline:
+Execution Plan
+============================================================
+
+Total Steps: 4
+Execution Phases: 4
+
+Phase 1:
+  → Execute :step1
+
+Phase 2:
+  → Execute :step2
+
+Phase 3:
+  → Execute :step3
+
+Phase 4:
+  → Execute :step4
+
+Performance Estimate:
+  Sequential execution: 4 time units
+  Parallel execution: 4 time units
+  Potential speedup: 1.0x
+
+
+Parallel Pipeline:
+Execution Plan
+============================================================
+
+Total Steps: 5
+Execution Phases: 3
+
+Phase 1:
+  → Execute :start
+
+Phase 2:
+  ⚡ Execute in parallel:
+     • :task1 (after :start)
+     • :task2 (after :start)
+     • :task3 (after :start)
+
+Phase 3:
+  → Execute :end
+
+Performance Estimate:
+  Sequential execution: 5 time units
+  Parallel execution: 3 time units
+  Potential speedup: 1.67x
+
+============================================================
+Direct pipeline visualization completed!
+
+Key Takeaway:
+  No need to manually recreate dependency structures!
+  Just call pipeline.visualize_ascii, pipeline.visualize_dot, etc.
+
+Generated files:
+  - pipeline_graph.dot
+  - pipeline_graph.mmd
+  - pipeline_graph.html
+============================================================

data/examples/regression_test/10_concurrency_control.txt

@@ -0,0 +1,96 @@
+============================================================
+Per-Pipeline Concurrency Control
+============================================================
+
+Async gem available: ✓ Yes
+
+Example 1: Auto-Detect Concurrency (Default)
+------------------------------------------------------------
+
+Pipeline concurrency setting: auto
+Will use: Async (fiber-based)
+
+
+Example 2: Force Threads
+------------------------------------------------------------
+
+Pipeline concurrency setting: threads
+Will use: Ruby Threads (even if async is available)
+  [Thread-based] Task A running...
+  [Thread-based] Task B running...
+  [Thread-based] Task C running...
+Result context: {task_c: :done}
+
+
+Example 3: Force Async
+------------------------------------------------------------
+
+Pipeline concurrency setting: async
+Will use: Async (fiber-based concurrency)
+  [Async] Validating...
+  [Async] Fetching A...
+  [Async] Fetching B...
+  [Async] Merging results...
+Result: Complete
+Context: {a: :done, b: :done}
+
+
+Example 4: Mixed Concurrency in Same Application
+------------------------------------------------------------
+
+User pipeline uses: threads
+Batch pipeline uses: async
+
+Running user pipeline...
+  [User/Threads] Validating user...
+  [User/Threads] Fetching profile...
+  [User/Threads] Fetching settings...
+User result: {profile: {name: "John"}, settings: {theme: "dark"}}
+
+Running batch pipeline...
+  [Batch/Async] Loading batch...
+  [Batch/Async] Processing batch 1...
+  [Batch/Async] Processing batch 2...
+Batch result: {batch_1: :done, batch_2: :done}
+
+
+Example 5: Error Handling
+------------------------------------------------------------
+
+Valid options: :auto, :threads, :async
+
+✓ Caught expected error for invalid concurrency:
+  Invalid concurrency option: :invalid. Valid options: [:auto, :threads, :async]
+
+
+
+Example 6: Inspecting Concurrency Settings
+------------------------------------------------------------
+
+Pipeline 1:
+  Concurrency: auto
+  Async available: true
+
+Pipeline 2:
+  Concurrency: auto
+  Async available: true
+
+Pipeline 3:
+  Concurrency: threads
+  Async available: true
+
+Pipeline 4:
+  Concurrency: async
+  Async available: true
+
+============================================================
+Concurrency control examples completed!
+============================================================
+
+Key Takeaways:
+  • concurrency: :auto (default) - auto-detects best option
+  • concurrency: :threads - always uses Ruby threads
+  • concurrency: :async - requires async gem, uses fibers
+  • Different pipelines can use different concurrency models
+  • Choose based on your specific workload requirements
+

data/examples/regression_test/11_sequential_dependencies.txt

@@ -0,0 +1,86 @@
+============================================================
+Sequential Step Dependencies
+============================================================
+
+Example 1: All Steps Succeed
+------------------------------------------------------------
+
+  [Step 1] Starting workflow...
+  [Step 2] Processing data...
+  [Step 3] Finalizing...
+
+Final result: 22
+Continue? true
+Expected: ((5 + 1) * 2) + 10 = 22
+
+
+Example 2: Pipeline Halts on Error
+------------------------------------------------------------
+
+  [Step 1] Validating input...
+  [Step 2] Checking business rules...
+
+Final result: -5
+Continue? false
+Errors: {business_rule: ["Value must be positive"]}
+Note: Step 3 never executed because Step 2 halted
+
+
+Example 3: Early Validation Pattern
+------------------------------------------------------------
+
+Scenario A: System in maintenance mode
+  [Pre-flight] Checking system health...
+Continue? false
+Errors: {system: ["Maintenance mode active"]}
+
+
+Scenario B: System healthy
+  [Pre-flight] Checking system health...
+  [Pre-flight] System healthy, proceeding...
+  [Step 1] Processing order...
+  [Step 2] Charging payment...
+  [Step 3] Sending confirmation...
+Continue? true
+All steps executed successfully!
+
+
+Example 4: Error Accumulation Before Halting
+------------------------------------------------------------
+
+  [Step 1] Collecting validation errors...
+  [Step 1] Found 2 validation error(s)
+
+Continue? false
+Errors found: 2
+All errors: ["Email required", "Must be 18+"]
+Note: Step 2 didn't execute because validation failed
+
+
+Example 5: Sequential vs Parallel Behavior
+------------------------------------------------------------
+
+Sequential execution order:
+  [Sequential 1] Step A
+  [Sequential 2] Step B (depends on A)
+  [Sequential 3] Step C (depends on B)
+
+Parallel execution (for comparison):
+  [Parallel] Step A (no dependencies)
+  [Parallel] Step B (depends on A)
+  [Parallel] Step C (depends on A, runs parallel with B)
+
+Note: Sequential steps have implicit dependencies
+      Parallel steps require explicit depends_on declarations
+
+============================================================
+Sequential dependencies examples completed!
+============================================================
+
+Key Takeaways:
+  • Unnamed steps execute sequentially in definition order
+  • Each step implicitly depends on the previous step's success
+  • Pipeline halts immediately when any step returns result.halt
+  • Subsequent steps after a halt are never executed
+  • Use named steps with depends_on for parallel execution
+

data/examples/regression_test/12_none_constant.txt

@@ -0,0 +1,64 @@
+============================================================
+Reserved Dependency Symbols Usage
+============================================================
+
+Example 1: Using :none Symbol for Better Readability
+------------------------------------------------------------
+
+  [Step 1] Validating input...
+  [Step 2a] Fetching orders in parallel...
+  [Step 2b] Fetching products in parallel...
+  [Step 3] Merging results...
+
+Result: {orders: [1, 2, 3], products: [:a, :b, :c], total: 6}
+Context: validated=true
+
+
+Example 2: :none Symbol vs Empty Array
+------------------------------------------------------------
+
+  [:none syntax] Root step with no dependencies
+  [Array syntax] Root step with no dependencies
+
+Both produce the same result: 6 == 6
+The :none symbol is simply more readable!
+
+
+Example 3: Multiple Independent Root Steps
+------------------------------------------------------------
+
+  [Root C] Authenticating API...
+  [Root B] Connecting to database...
+  [Root A] Loading configuration...
+  [Final] Initializing application with all resources...
+
+Result: Application ready
+All independent steps ran in parallel!
+
+
+Example 4: Reserved Dependency Symbols
+------------------------------------------------------------
+
+You can use :none or :nothing to indicate no dependencies:
+
+  • :step_a dependencies: []
+  • :step_b dependencies: []
+  • :step_c dependencies: [:step_a, :step_b] (filtered!)
+
+Reserved symbols :none and :nothing:
+  • Automatically filtered from dependency arrays
+  • Functionally equivalent to []
+  • More semantically clear than empty array
+  • Cannot be used as step names (reserved)
+  • A signal to readers: 'this step has no dependencies'
+
+============================================================
+Reserved dependency symbols examples completed!
+============================================================
+
+Key Takeaways:
+  • Use depends_on: :none for better readability
+  • Equivalent to [] but more semantic
+  • Can mix in arrays: [:step_a, :none] becomes [:step_a]
+  • Makes dependency graphs easier to understand
+

data/examples/regression_test.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Regression Test Runner
+# Runs all example scripts and saves their output to regression_test/ directory
+# for comparison purposes.
+
+require 'fileutils'
+
+class RegressionTestRunner
+  EXAMPLES_DIR = File.dirname(__FILE__)
+  OUTPUT_DIR = File.join(EXAMPLES_DIR, 'regression_test')
+
+  def initialize
+    @examples = Dir.glob(File.join(EXAMPLES_DIR, '*.rb'))
+                   .reject { |f| File.basename(f) == 'regression_test.rb' }
+                   .sort
+  end
+
+  def run
+    puts "Regression Test Runner"
+    puts "=" * 60
+    puts "Output directory: #{OUTPUT_DIR}"
+    puts "Found #{@examples.size} example files"
+    puts
+
+    ensure_output_directory
+
+    results = @examples.map { |example| run_example(example) }
+
+    print_summary(results)
+  end
+
+  private
+
+  def ensure_output_directory
+    FileUtils.mkdir_p(OUTPUT_DIR) unless Dir.exist?(OUTPUT_DIR)
+  end
+
+  def run_example(example_path)
+    basename = File.basename(example_path, '.rb')
+    output_path = File.join(OUTPUT_DIR, "#{basename}.txt")
+
+    print "Running #{basename}... "
+
+    start_time = Time.now
+    output, status = capture_output(example_path)
+    elapsed = Time.now - start_time
+
+    File.write(output_path, output)
+
+    if status.success?
+      puts "OK (#{format('%.2f', elapsed)}s) -> #{File.basename(output_path)}"
+      { name: basename, success: true, elapsed: elapsed, output_path: output_path }
+    else
+      puts "FAILED (exit code: #{status.exitstatus})"
+      { name: basename, success: false, elapsed: elapsed, output_path: output_path, exit_code: status.exitstatus }
+    end
+  end
+
+  def capture_output(example_path)
+    output = `cd #{EXAMPLES_DIR} && ruby #{File.basename(example_path)} 2>&1`
+    [output, $?]
+  end
+
+  def print_summary(results)
+    puts
+    puts "=" * 60
+    puts "SUMMARY"
+    puts "=" * 60
+
+    successful = results.count { |r| r[:success] }
+    failed = results.count { |r| !r[:success] }
+    total_time = results.sum { |r| r[:elapsed] }
+
+    puts "Total examples: #{results.size}"
+    puts "Successful: #{successful}"
+    puts "Failed: #{failed}"
+    puts "Total time: #{format('%.2f', total_time)}s"
+    puts
+
+    if failed > 0
+      puts "Failed examples:"
+      results.reject { |r| r[:success] }.each do |result|
+        puts "  - #{result[:name]} (exit code: #{result[:exit_code]})"
+      end
+      puts
+    end
+
+    puts "Output files saved to: #{OUTPUT_DIR}/"
+    puts
+
+    # List generated files
+    puts "Generated files:"
+    results.each do |result|
+      file_size = File.size(result[:output_path])
+      puts "  #{File.basename(result[:output_path])} (#{file_size} bytes)"
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  runner = RegressionTestRunner.new
+  runner.run
+end