ruby_reactor 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 598c9e49f00183da45e7b370c394445e9efddfe5952e3aabd701bbf954aa9712
-  data.tar.gz: 949ed81bd787d7bee47284e7f7b5905af3de4ae4057a90a4d0afa707959f5cbb
+  metadata.gz: 863c83e92cbfab470e39107c580ceabce444133973b723662a89e5bf0211c3ab
+  data.tar.gz: 1209b5587efc055bc787731694a6dc2b7eab8b3d5a6ff729728aa29ea601e2e0
 SHA512:
-  metadata.gz: ae8f8f8a2916254068757d79d352df0a0148d4693f92238b456cecc1cb90d9f6cc77087f2b486e3359f5f0042779aecc9112df1da9898fa8efba6c9ed425ef39
-  data.tar.gz: 14fcbf6f880396176503008239e6517415977b19193f3f0d8600226acb7cf53d54a18bb79a42012646a1746d3202a62b73479715b6d088f69c208ce1c143aa92
+  metadata.gz: 146d14cd32b12c95764e493f2de2d826dbe074ec4e4b44613b788d748d52fe38644fd86f1590f6bb0b1a0d1840c2200ab29a6d8e78db27f8f6abf099faf74756
+  data.tar.gz: 3d5b7c43182ee2d1c5c06ba90b7e2177a3dffbecdc8fb3e91db14f99bcd02807ebfa98c0e240412b790ec1d69609dc30995d9ee1aea9c8cb8ecd69d4d0fb2ac7

data/README.md

@@ -1,5 +1,16 @@
+[![Gem Version](https://badge.fury.io/rb/ruby_reactor.svg)](https://badge.fury.io/rb/ruby_reactor)
+[![Build Status](https://github.com/arturictus/ruby_reactor/actions/workflows/main.yml/badge.svg)](https://github.com/arturictus/ruby_reactor/actions)  <!-- if you have CI -->
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
+[![Downloads](https://img.shields.io/gem/dt/ruby_reactor.svg)](https://rubygems.org/gems/ruby_reactor)
+
 # RubyReactor
 
+## Why Ruby Reactor?
+
+Building complex business transactions often results in spaghetti code or brittle "god classes." Ruby Reactor solves this by implementing the **Saga Pattern** in a lightweight, developer-friendly package. It lets you define workflows as clear, dependency-driven steps without the boilerplate of heavy enterprise frameworks.
+
+The key value is **Reliability**: if any part of your workflow fails, Ruby Reactor automatically triggers compensation logic to undo previous steps, ensuring your system never ends up in a corrupted half-state. Whether you're coordinating microservices or monolith modules, you get atomic-like consistency with background processing built-in.
+
 A dynamic, dependency-resolving saga orchestrator for Ruby. Ruby Reactor implements the Saga pattern with compensation-based error handling and DAG-based execution planning. It leverages **Sidekiq** for asynchronous execution and **Redis** for state persistence.
 
 ![Payment workflow reactor](documentation/images/payment_workflow.png)
@@ -14,6 +25,49 @@ A dynamic, dependency-resolving saga orchestrator for Ruby. Ruby Reactor impleme
 - **Interrupts**: Pause and resume workflows to wait for external events (webhooks, user approvals).
 - **Input Validation**: Integrated with `dry-validation` for robust input checking.
 
+## Comparison
+
+| Feature                  | Ruby Reactor | dry-transaction | Trailblazer | Custom Sidekiq Jobs |
+|--------------------------|--------------|-----------------|-------------|---------------------|
+| DAG/Parallel execution   | Yes          | No              | Limited     | Manual              |
+| Auto compensation/undo   | Yes          | No              | Manual      | Manual              |
+| Interrupts (pause/resume)| Yes          | No              | No          | Manual              |
+| Built-in web dashboard   | Yes          | No              | No          | No                  |
+| Async with Sidekiq       | Yes          | No              | Limited     | Yes                 |
+
+## Real-World Use Cases
+
+- **E-commerce Checkout**: Orchestrate inventory reservation, payment authorization, and shipping label generation. If payment fails, automatically release inventory and cancel the shipping request.
+- **Data Import Pipelines**: Ingest optional massive CSVs using `map` steps to validate and upsert records in parallel. If data validation fails for a chunk, fail fast or collect errors while letting valid chunks succeed.
+- **Subscription Billing**: Coordinate Stripe charges, invoice email generation, and internal entitlement updates. Use interrupts to pause the workflow when 3rd-party APIs are required to continue the workflow or when specific customer approval is needed.
+
+## Table of Contents
+- [Features](#features)
+- [Comparison](#comparison)
+- [Real-World Use Cases](#real-world-use-cases)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Quick Start](#quick-start)
+- [Web Dashboard](#web-dashboard)
+  - [Rails Installation](#rails-installation)
+- [Usage](#usage)
+  - [Basic Example: User Registration](#basic-example-user-registration)
+  - [Async Execution](#async-execution)
+    - [Full Reactor Async](#full-reactor-async)
+    - [Step-Level Async](#step-level-async)
+  - [Interrupts (Pause & Resume)](#interrupts-pause--resume)
+  - [Map & Parallel Execution](#map--parallel-execution)
+    - [Map with Dynamic Source (ActiveRecord)](#map-with-dynamic-source-activerecord)
+  - [Input Validation](#input-validation)
+  - [Complex Workflows with Dependencies](#complex-workflows-with-dependencies)
+  - [Error Handling and Compensation](#error-handling-and-compensation)
+  - [Using Pre-defined Schemas](#using-pre-defined-schemas)
+- [Documentation](#documentation)
+- [Future improvements](#future-improvements)
+- [Development](#development)
+- [Contributing](#contributing)
+- [Code of Conduct](#code-of-conduct)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -50,6 +104,21 @@ RubyReactor.configure do |config|
 end
 ```
 
+
+## Quick Start
+
+```ruby
+class HelloReactor < RubyReactor::Reactor
+  step :greet do
+    run { Success("Hello from Ruby Reactor!") }
+  end
+  returns :greet
+end
+
+result = HelloReactor.run
+puts result.value  # => "Hello from Ruby Reactor!"
+```
+
 ## Web Dashboard
 
 RubyReactor comes with a built-in web dashboard to inspect reactor executions, view logs, and retry failed steps.
@@ -281,6 +350,42 @@ class DataProcessingReactor < RubyReactor::Reactor
 end
 ```
 
+By using `async true` with `batch_size`, the system applies **Back Pressure** to efficiently manage resources. [Read more about Back Pressure & Resource Management](documentation/data_pipelines.md#back-pressure--resource-management).
+
+#### Map with Dynamic Source (ActiveRecord)
+
+You can use a block for `source` to dynamically fetch data, such as from ActiveRecord queries. The result is wrapped in a `ResultEnumerator` for easy access to successes and failures.
+
+```ruby
+map :archive_old_users do
+  argument :days, input(:days)
+
+  # Dynamic source using ActiveRecord
+  source do |args|
+    User.where("last_login_at < ?", args[:days].days.ago)
+  end
+  
+  argument :user, element(:archive_old_users)
+  async true, batch_size: 100
+
+  step :archive do
+    argument :user, input(:user)
+    run { |args| args[:user].archive! }
+  end
+  
+  returns :archive
+end
+
+step :summary do
+  argument :results, result(:archive_old_users)
+  run do |args|
+    puts "Archived: #{args[:results].successes.count}"
+    puts "Failed: #{args[:results].failures.count}"
+    Success()
+  end
+end
+```
+
 ### Input Validation
 
 RubyReactor integrates with dry-validation for input validation:

data/Rakefile

@@ -30,8 +30,8 @@ namespace :server do
   end
 end
 
-# require "rubocop/rake_task"
+require "rubocop/rake_task"
 
-# RuboCop::RakeTask.new
+RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]

data/documentation/data_pipelines.md

@@ -43,53 +43,35 @@ class UserTransformationReactor < RubyReactor::Reactor
 end
 ```
 
-## Async Execution
+## Dynamic Sources & ActiveRecord
 
-For long-running or resource-intensive tasks, you can offload processing to background jobs using Sidekiq.
-
-To enable async execution, simply add the `async true` directive to your map definition.
+The `map` step supports a dynamic `source` block, which is particularly useful when working with ActiveRecord or when the collection depends on input arguments. Instead of passing a static collection, you can define a block that returns an Enumerable or an `ActiveRecord::Relation`.
 
 ```ruby
-map :process_orders do
-  source input(:orders)
-  argument :order, element(:process_orders)
-  
-  # Enable async execution via Sidekiq
-  async true
-
-  step :charge_card do
-    argument :order, input(:order)
-    run { PaymentService.charge(args[:order]) }
+map :process_products do
+  argument :filter, input(:filter)
+
+  # Dynamic source block
+  source do |args|
+    # This block executes at runtime
+    threshold = args[:filter][:stock]
+    Product.where("stock >= ?", threshold)
   end
 
-  returns :charge_card
+  argument :product, element(:process_products)
+  async true, batch_size: 100
+
+  step :process do
+    # ...
+  end
+  
+  returns :process
 end
 ```
 
-### Execution Flow
-
-```mermaid
-sequenceDiagram
-    participant Reactor
-    participant Redis
-    participant Sidekiq
-    participant Worker
-
-    Reactor->>Redis: Store Context
-    Reactor->>Sidekiq: Enqueue MapElementWorkers
-    Note over Reactor: Returns AsyncResult immediately
-    
-    loop For each element
-        Sidekiq->>Worker: Process Element
-        Worker->>Redis: Update Element Result
-    end
-
-    Worker->>Sidekiq: Enqueue MapCollectorWorker (when done)
-    Sidekiq->>Worker: Run Collector
-    Worker->>Redis: Store Final Result
-```
+When an `ActiveRecord::Relation` is returned, RubyReactor efficiently batches the query using database-level `OFFSET` and `LIMIT` based on the configured `batch_size`, preventing memory bloat by not loading all records at once.
 
-## Batch Processing
+## Batch Processing Mechanism
 
 When processing large datasets asynchronously, you can control the parallelism using `batch_size`. This limits how many Sidekiq jobs are enqueued simultaneously, preventing system overload.
 
@@ -107,10 +89,42 @@ map :bulk_import do
 end
 ```
 
-**How it works:**
-1. The system initially enqueues `batch_size` jobs.
-2. As each job completes, it triggers the next job in the queue.
-3. This maintains a steady stream of processing without flooding the queue.
+### Back Pressure & Resource Management
+
+When `async true` is used with a `batch_size`, RubyReactor implements an intelligent **back pressure** mechanism. Instead of flooding Redis and Sidekiq with millions of jobs immediately (which is the standard behavior for many background job systems), the system processes data in controlled chunks.
+
+This approach provides critical benefits for stability and scalability:
+
+1.  **Memory Efficiency**: By using `ActiveRecord` batching (`LIMIT` / `OFFSET`), only the current batch of records is loaded into memory. This allows processing datasets larger than available RAM.
+2.  **Redis Protection**: Prevents "Queue Explosion". Only a small number of job arguments are stored in Redis at any time, preventing OOM errors in your Redis instance.
+3.  **Database Stability**: Database load is distributed over time rather than spiking all at once.
+
+**Visualizing the Flow:**
+
+```mermaid
+graph TD
+    Start[Start Map] -->|Batch Size: N| BatchManager
+    
+    subgraph "Back Pressure Loop"
+        BatchManager[Batch Manager] -->|Fetch N Items| DB[(Database)]
+        DB --> Records
+        Records -->|Enqueue N Jobs| Sidekiq
+        
+        Sidekiq --> W1[Worker 1]
+        Sidekiq --> W2[Worker 2]
+        
+        W1 -.->|Complete| Check{Batch Done?}
+        W2 -.->|Complete| Check
+        
+        Check -->|No| Wait[Wait]
+        Check -->|Yes| Next[Trigger Next Batch]
+        Next --> BatchManager
+    end
+    
+    BatchManager -->|No More Items| Finish[Aggregator]
+```
+
+This ensures that the system works at the speed of your workers, not the speed of the enqueueing process, maintaining a constant and manageable resource footprint regardless of dataset size.
 
 ## Error Handling
 
@@ -128,9 +142,9 @@ map :strict_processing do
 end
 ```
 
-### Collecting Partial Results
+### Collecting Results (Successes & Failures)
 
-If you want to process all elements regardless of failures, set `fail_fast false`. You can then use a `collect` block to handle successes and failures separately.
+If you want to process all elements regardless of failures, set `fail_fast false`. The map step returns a `ResultEnumerator` that allows you to easily separate successful executions from failures.
 
 ```ruby
 map :resilient_processing do
@@ -145,18 +159,39 @@ map :resilient_processing do
   end
 
   returns :risky_operation
+end
+
+step :analyze_results do
+  argument :results, result(:resilient_processing)
+  
+  run do |args|
+    col = args[:results]
+    
+    # Iterate over successful results
+    col.successes.each do |value|
+      # 'value' is the direct return value of the map element
+      puts "Success: #{value}"
+    end
+
+    # Iterate over failures
+    col.failures.each do |error|
+      # 'error' is the failure object/message itself
+      puts "Error: #{error}"
+    end
+
+    # Note: Iterating the collection directly yields wrapped objects
+    col.each do |result|
+      if result.is_a?(RubyReactor::Success)
+        puts "Wrapped Value: #{result.value}"
+      else
+        puts "Wrapped Error: #{result.error}"
+      end
+    end
 
-  # Aggregate results
-  collect do |results|
-    # results is an array of Result objects (Success or Failure)
-    successful = results.select(&:success?).map(&:value)
-    failed = results.select(&:failure?).map(&:error)
-
-    {
-      processed: successful,
-      errors: failed,
-      success_rate: successful.length.to_f / results.length
-    }
+    Success({
+      success_count: col.successes.count,
+      failure_count: col.failures.count
+    })
   end
 end
 ```
@@ -192,33 +227,4 @@ end
 - **Async Mode**: Retries are handled by requeuing the Sidekiq job with a delay. This is non-blocking and efficient.
 - **Sync Mode**: Retries happen immediately within the execution thread (blocking).
 
-## Visualization
 
-### Async Batch Execution
-
-```mermaid
-graph TD
-    Start[Start Map] --> Init[Initialize Batch]
-    Init --> Q1["Queue Initial Batch<br/>(Size N)"]
-    
-    subgraph Workers
-        W1[Worker 1]
-        W2[Worker 2]
-        W3[Worker ...]
-    end
-    
-    Q1 --> W1
-    Q1 --> W2
-    
-    W1 -->|Complete| Next1{More Items?}
-    W2 -->|Complete| Next2{More Items?}
-    
-    Next1 -->|Yes| Q2[Queue Next Item]
-    Next2 -->|Yes| Q2
-    
-    Q2 --> W3
-    
-    Next1 -->|No| Check{All Done?}
-    Check -->|Yes| Collect[Run Collector]
-    Collect --> Finish[Final Result]
-```

data/lib/ruby_reactor/async_router.rb

@@ -19,7 +19,7 @@ module RubyReactor
     # 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,
@@ -32,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
@@ -75,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,
@@ -86,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_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/dsl/map_builder.rb

@@ -32,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/executor/result_handler.rb

@@ -117,6 +117,7 @@ module RubyReactor
 
       def store_failed_map_context(context)
         return unless context.map_metadata && context.map_metadata[:map_id]
+        return unless context.map_metadata[:fail_fast]
 
         storage = RubyReactor.configuration.storage_adapter
         storage.store_map_failed_context_id(

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -39,7 +39,17 @@ module RubyReactor
 
         # Serialize context and requeue the job
         # Use root context if available to ensure we serialize the full tree
-        context_to_serialize = @context.root_context || @context
+        # BUT for map elements (which have map_metadata), we must serialize the element context itself
+
+        context_to_serialize = if @context.map_metadata
+                                 @context
+                               else
+                                 @context.root_context || @context
+                               end
+
+        puts "SERIALIZING CONTEXT: #{context_to_serialize.reactor_class.name}"
+        puts "INPUTS KEYS: #{context_to_serialize.inputs.keys}" if context_to_serialize.respond_to?(:inputs)
+
         reactor_class_name = context_to_serialize.reactor_class.name
 
         serialized_context = ContextSerializer.serialize(context_to_serialize)

data/lib/ruby_reactor/map/collector.rb

@@ -7,56 +7,94 @@ module RubyReactor
 
       def self.perform(arguments)
         arguments = arguments.transform_keys(&:to_sym)
-        parent_context_id = arguments[:parent_context_id]
         map_id = arguments[:map_id]
+        parent_context_id = arguments[:parent_context_id]
         parent_reactor_class_name = arguments[:parent_reactor_class_name]
         step_name = arguments[:step_name]
         strict_ordering = arguments[:strict_ordering]
+        # timeout = arguments[:timeout]
 
         storage = RubyReactor.configuration.storage_adapter
+        parent_context_data = storage.retrieve_context(parent_context_id, parent_reactor_class_name)
+        parent_context = RubyReactor::Context.deserialize_from_retry(parent_context_data)
+
+        # Check if all tasks are completed
+        metadata = storage.retrieve_map_metadata(map_id, parent_reactor_class_name)
+        total_count = metadata ? metadata["count"].to_i : 0
+
+        results_count = storage.count_map_results(map_id, parent_reactor_class_name)
+
+        # Not done yet, requeue or wait?
+        # Actually Collector currently assumes we only call it when we expect completion or check progress
+        # Since map_offset tracks dispatching progress and might exceed count due to batching reservation,
+        # we must strictly check against the total count of elements.
+        # Check for fail_fast failure FIRST
+        failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name)
+        if failed_context_id
+          # Resolve the class of the mapped reactor to retrieve its context
+          reactor_class = resolve_reactor_class(metadata["reactor_class_info"])
 
-        # Retrieve parent context
-        parent_context = load_parent_context_from_storage(
-          parent_context_id,
+          failed_context_data = storage.retrieve_context(failed_context_id, reactor_class.name)
+
+          if failed_context_data
+            failed_context = RubyReactor::Context.deserialize_from_retry(failed_context_data)
+
+            # Resume parent execution (which marks step as failed)
+            resume_parent_execution(parent_context, step_name, RubyReactor::Failure(failed_context.failure_reason),
+                                    storage)
+            return
+          end
+        end
+
+        return if results_count < total_count
+
+        # Retrieve results lazily
+        results = RubyReactor::Map::ResultEnumerator.new(
+          map_id,
           parent_reactor_class_name,
-          storage
+          strict_ordering: strict_ordering
         )
 
-        # Retrieve results
-        serialized_results = storage.retrieve_map_results(map_id, parent_reactor_class_name,
-                                                          strict_ordering: strict_ordering)
+        # Apply collect block (or default collection)
+        step_config = parent_context.reactor_class.steps[step_name.to_sym]
 
-        results = serialized_results.map do |r|
-          if r.is_a?(Hash) && r.key?("_error")
-            RubyReactor::Failure(r["_error"])
-          else
-            RubyReactor::Success(r)
+        begin
+          final_result = apply_collect_block(results, step_config)
+
+          if final_result.failure?
+            # Optionally log failure internally or just rely on context status update
           end
+        rescue StandardError => e
+          final_result = RubyReactor::Failure(e)
         end
 
-        # Get step config to check for collect block and other options
-        parent_class = Object.const_get(parent_reactor_class_name)
-        step_config = parent_class.steps[step_name.to_sym]
+        # Resume parent execution
+        resume_parent_execution(parent_context, step_name, final_result, storage)
+      rescue StandardError => e
+        puts "COLLECTOR CRASH: #{e.message}"
+        puts e.backtrace
+        raise e
+      end
 
-        collect_block = step_config.arguments[:collect_block][:source].value
+      def self.apply_collect_block(results, step_config)
+        collect_block = step_config.arguments[:collect_block][:source].value if step_config.arguments[:collect_block]
         # TODO: Check allow_partial_failure option
 
-        final_result = if collect_block
-                         begin
-                           # Pass all results (Success and Failure) to collect block
-                           collected = collect_block.call(results)
-                           RubyReactor::Success(collected)
-                         rescue StandardError => e
-                           RubyReactor::Failure(e)
-                         end
-                       else
-                         # Default behavior: fail if any failure
-                         first_failure = results.find(&:failure?)
-                         first_failure || RubyReactor::Success(results.map(&:value))
-                       end
-
-        # Resume execution
-        resume_parent_execution(parent_context, step_name, final_result, storage)
+        if collect_block
+          begin
+            # Pass Enumerator to collect block
+            collected = collect_block.call(results)
+            RubyReactor::Success(collected)
+          rescue StandardError => e
+            puts "COLLECTOR INNER EXCEPTION: #{e.message}"
+            puts e.backtrace
+            RubyReactor::Failure(e)
+          end
+        else
+          # Default behavior: Return Success(Enumerator).
+          # Logic for checking failures is deferred to the consumer of the enumerator.
+          RubyReactor::Success(results)
+        end
       end
     end
   end