flow_organizer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9e30234c35b2d539513015dc954803f4c3d09ac52c7ddcbf0c38a281f368e9c
+  data.tar.gz: 734b2178425821c8979e7b386a35a0e562cf204f1ab00a1fd33b693812683ddf
+SHA512:
+  metadata.gz: 1b82678836b3adb059630cb315f7b3af8442e6c5a5386783076aff91b3d1f2cd9b0a758e57ae44f748ff6ca46702b53711972b337df59c9447cf797da892aeb1
+  data.tar.gz: b9cd76c5d0c4b7ce35bf3d064a8913dae32d0821c630a12048969cc8332bdefdc5a4adec8c952d22d047cf6a91f3a11d0e75d09279cbce977b6217a951172971

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format follows [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).
+
+## [1.0.0] — 2026-06-27
+
+Initial release.
+
+### Added
+
+- Sequential callable dispatch with a shared context hash threaded through each
+  step (`FlowOrganizer.call(list:, ctx:)`).
+- Result-tuple contract: `[:ok]`, `[:halt]`, `[:error]`, each with an optional
+  context update hash.
+- Dual-track execution: when a step on `list:` errors, execution switches to
+  `list_error:` (Railway-style compensation track).
+- Pluggable callable resolvers:
+  - Raw callables (anything responding to `#call`).
+  - `FlowOrganizer::Callable::Alias` — register a callable under a symbol and
+    reference it as `[:alias, :name]` in a list.
+  - `FlowOrganizer::Callable::Branch` — pick a sub-pipeline based on the value
+    returned by a branch-selector callable.
+- Parameter introspection cache on `FlowOrganizer::Context` — slice spec is
+  computed once per callable, then reused. ~1.8× faster dispatch on warm
+  pipelines. Clearable via `clear_parameter_cache` for reloading.
+- Configurable exception reporter: assign a callback to
+  `FlowOrganizer.exception_reporter` to forward caught exceptions to
+  Sentry/Honeybadger/etc.
+- Forgiving `sanitize_errors` shorthand: callables may return errors as
+  `String`, `Hash`, or `Array`, and they are normalized to
+  `{ errors: [{ title: ... }] }` shape.
+
+[1.0.0]: https://github.com/nathan-appere/ruby-flow-organizer/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nathan Appere
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# FlowOrganizer
+
+Run a list of callables in sequence, threading a context hash through each step. A small,
+allocation-conscious "functional interactor" / Railway-style pipeline.
+
+```ruby
+FlowOrganizer.call(
+  list: [
+    ->(email:)            { [:ok, normalized_email: email.downcase.strip] },
+    ->(normalized_email:) { [:ok, user: User.find_by(email: normalized_email)] },
+    ->(user:)             { user ? [:ok] : [:error, code: 'user.not_found'] },
+    ->(user:)             { [:ok, token: Auth.issue_token(user)] },
+  ],
+  ctx: { email: ' Alice@Example.com ' },
+)
+# => [:ok, { email: ..., normalized_email: ..., user: ..., token: ... }]
+```
+
+## Why
+
+The pattern is known under many names: Pipes and Filters, Pipeline, Railway-Oriented
+Programming, functional interactor.
+
+The core idea: a list of small operations passes a shared context forward, any one of them can stop the chain by returning an error, and the caller gets back a single `[status, ctx]` tuple.
+
+Comparable Ruby gems include
+[`interactor`](https://github.com/collectiveidea/interactor),
+[`light-service`](https://github.com/adomokos/light-service), and
+[`dry-transaction`](https://dry-rb.org/gems/dry-transaction/).
+
+FlowOrganizer trades their OOP approach & custom DSL for a `functional` approach: any callable can be used (lambda, method, or `#call`-responding objects). No need to have every step be a new Class.
+
+## Installation
+
+Requires Ruby 3.2+.
+
+```ruby
+# Gemfile
+gem 'flow_organizer'
+```
+
+```sh
+bundle install
+# or
+gem install flow_organizer
+```
+
+## The callable contract
+
+Every callable must return one of:
+
+| Return                     | Meaning                                              |
+| -------------------------- | ---------------------------------------------------- |
+| `[:ok]`                    | Success, no context update.                          |
+| `[:ok, { key: value }]`    | Success, merge the hash into the context.            |
+| `[:halt]`                  | Stop the chain. The caller still sees a final `:ok`. |
+| `[:halt, { key: value }]`  | Same as above, with a final context update.          |
+| `[:error]`                 | Stop the chain. Caller sees `:error`.                |
+| `[:error, errors_payload]` | As above, with a normalized `errors:` array in ctx.  |
+
+For `:error`, the payload can be a string, a hash with `:title`/`:detail`/`:code`, an array of either, or already a `{ errors: [...] }` hash.
+FlowOrganizer normalizes them all to the canonical `{ errors: [{ title: ... }, ...] }` shape.
+
+Callables only receive the context keys their kwargs declare:
+
+```ruby
+->(value:)            { ... }     # gets { value: ... }
+->(value:, other:)    { ... }     # gets { value: ..., other: ... }
+->(**)                { ... }     # gets the full ctx
+->()                  { ... }     # gets nothing
+```
+
+Positional arguments are not supported: this is what lets it cheaply slice the context per step.
+
+## Dual-track execution
+
+Pass `list_error:` to run a compensation track if the success track fails:
+
+```ruby
+FlowOrganizer.call(
+  list:       [book_flight, charge_card, send_confirmation],
+  list_error: [refund_card, send_apology],
+  ctx:        { user: user, flight: flight },
+)
+```
+
+If `charge_card` returns `[:error]`, execution jumps to `refund_card` with the accumulated context.
+
+## Resolvers
+
+Anything responding to `#call` works directly. For more structured lists, two extras ship in the box.
+
+## Exception handling
+
+A callable that raises is caught and turned into `[:error, { error: <exception> }]`.
+Two knobs change the default:
+
+```ruby
+# Re-raise instead of catching.
+FlowOrganizer.call(list: [...], ctx: { ... }, raise_exception: true)
+
+# Forward caught exceptions to your error reporter.
+FlowOrganizer.exception_reporter = ->(exception:) { Sentry.capture_exception(exception) }
+```
+
+## Performance
+
+The included benchmark compares plain chained lambda calls against `FlowOrganizer.call`
+with a 5-step pipeline, 20 000 iterations:
+
+```
+                               total        per-call ratio     vs baseline
+  plain chained calls           16.05 ms     0.80 µs   1.00x   (baseline)
+  flow_organizer (cached)       78.42 ms     3.92 µs   4.87x   +388%
+  flow_organizer (uncached)    158.92 ms     7.95 µs   9.90x   +890%
+```
+
+Run it locally:
+
+```sh
+ruby benchmark/flow_organizer_overhead.rb
+```
+
+The parameter-introspection cache is on by default and warms automatically. Call `FlowOrganizer::Context.clear_parameter_cache` if you reload code in development and want to drop stale `Method` objects.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/flow_organizer/callable/alias.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# Allows registration of a callable in a local store with an alias name.
+# It can be used later by using the alias.
+#
+# ## Registering the alias
+#
+# ```ruby
+# callable = ->(counter:) { [:ok, counter: counter + 1]}
+# FlowOrganizer::Callable::Alias.register(id: :increment_counter, target: callable)
+# ```
+#
+# ## Using the alias
+#
+# ```ruby
+# FlowOrganizer::FlowOrganizer.call(
+#   list: [
+#     [:alias, :increment_counter],
+#   ],
+#   ctx: { counter: 1 },
+# )
+# ```
+module FlowOrganizer::Callable::Alias
+
+  # Resolves `alias_name` to the registered `:callable`
+  # @note The expected format is `[:alias, alias_name]`.
+  def self.resolve(args:, store: nil)
+    _, alias_name = args
+    store ||= local_store
+
+    [:ok, callable: get(id: alias_name, store:)]
+  end
+
+  # Saves a `:target` in the alias store, identified by `:id`
+  def self.register(id:, target:, store: nil)
+    store ||= local_store
+
+    store[id.to_sym] = {
+      target:,
+    }
+  end
+
+  # Get the alias identified with `:id`
+  def self.get(id:, store: nil)
+    store ||= local_store
+    record = store[id.to_sym]
+
+    if !record
+      raise "FlowOrganizer::Callable::Alias | unknown alias `#{ id }`"
+    end
+
+    record[:target]
+  end
+
+  # Create a store to save organizer's aliases
+  def self.create_store
+    {}
+  end
+
+  # Default store when not specified as a parameter
+  def self.local_store
+    @local_store ||= create_store
+  end
+
+end

data/lib/flow_organizer/callable/branch.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# Call the branch which name is returned by `branch_callable`.
+#
+# ## Example
+#
+# ```ruby
+# FlowOrganizer.call(
+#   list: [
+#     [:branch, ->(number:) { number.even? ? :even : :odd }, {
+#       even: [
+#         ->() { some_action },
+#       ],
+#       odd: [
+#         ->() { some_other_action },
+#       ],
+#     },],
+#   ],
+#   ctx: { number: rand(1...10) },
+# )
+# ```
+module FlowOrganizer::Callable::Branch
+
+  # The expected format for `:args` is `[:branch, branch_callable, branch_list]`
+  def self.resolve(args:)
+    _, callable, branches = args
+
+    wrapped_callable = ->(**arguments) do
+      ctx_in = arguments || {}
+
+      branch_name, _ctx_out = FlowOrganizer.call(
+        list: [callable],
+        ctx:  ctx_in,
+      )
+
+      status  = :ok
+      ctx_out = {}
+      list    = branches[branch_name]
+
+      if list && !list.empty?
+        status, ctx_out = FlowOrganizer.call(
+          list: branches[branch_name],
+          ctx:  ctx_in,
+        )
+
+        ctx_out = (ctx_out) ? FlowOrganizer::Context.update_context(ctx: ctx_in, local_ctx: ctx_out) : ctx_in
+      end
+
+      [status, ctx_out]
+    end
+
+    [:ok, callable: wrapped_callable]
+  end
+
+end

data/lib/flow_organizer/callable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# This module makes FlowOrganizer extensible. You can add your own behaviours to resolve callables.
+module FlowOrganizer::Callable
+
+  # Local store to add custom behaviours.
+  def self.store
+    @store ||= {
+      alias:  FlowOrganizer::Callable::Alias.method(:resolve),
+      branch: FlowOrganizer::Callable::Branch.method(:resolve),
+    }
+  end
+
+  # Transform each target to a callable. This is delegated to submodules registered in the local `store`.
+  # @param target A callable or some data that can be transformed to a callable
+  # @return A callable
+  def self.resolve(target:)
+    if target.respond_to?(:call)
+      [:ok, callable: target]
+    else
+      type = target[0]
+      if store[type]
+        store[type].call(args: target)
+      else
+        [:error, "FlowOrganizer could not resolve callable type `#{ type }`"]
+      end
+    end
+  end
+
+end

data/lib/flow_organizer/context.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# Handle context operations.
+module FlowOrganizer::Context
+
+  # Performs a 1 level deep merge on the organizer context.
+  # @api private
+  # @note The content of the `:errors` key is merged manually.
+  def self.update_context(ctx:, local_ctx:)
+    local_ctx ||= {}
+    ctx_errors  = ctx[:errors]
+
+    # NOTE: 1 level deep only (not a deep merge)
+    ctx = ctx.merge(local_ctx)
+
+    if ctx_errors
+      ctx[:errors] = ctx_errors + (local_ctx[:errors] || [])
+    end
+
+    ctx
+  end
+
+  # In-place variant of `update_context`. The caller must already own `ctx`
+  # (e.g. it was `dup`ed at the top of `FlowOrganizer.call`). Used on the dispatch
+  # hot path to avoid allocating a fresh hash per callable.
+  # @api private
+  def self.update_context!(ctx:, local_ctx:)
+    return ctx if local_ctx.nil? || local_ctx.empty?
+
+    ctx_errors   = ctx[:errors]
+    local_errors = local_ctx[:errors]
+
+    ctx.merge!(local_ctx)
+
+    if ctx_errors
+      ctx[:errors] = ctx_errors + (local_errors || [])
+    end
+
+    ctx
+  end
+
+  # Extract needed key from the organizer context to send them to the callable.
+  # @api private
+  # @note This id done by using introspection on the callable.
+  # @example
+  #    generate_callable_ctx(callable: ->(a:), { a: 1, b: 2, c: 3 }) => { a: 1 }
+  #    generate_callable_ctx(callable: ->(a:, **), { a: 1, b: 2, c: 3 }) => { a: 1, b: 2, c: 3 }
+  def self.generate_callable_ctx(callable:, ctx:)
+    spec = parameter_cache[callable] ||= compute_parameter_spec(callable:)
+
+    case spec
+    when :keyrest
+      ctx.dup
+    when :none
+      nil
+    else
+      ctx.slice(*spec)
+    end
+  end
+
+  # Given a `callable`, get its `parameters` data
+  def self.get_parameters(callable:)
+    if callable.is_a?(Proc) || callable.is_a?(Method)
+      callable.parameters
+    elsif callable.respond_to?(:call)
+      callable.method(:call).parameters
+    else
+      # NOTE: this should not be callable :)
+      raise FlowOrganizer::Error.new("Unsupported callable #{ callable.class } `#{ callable }`")
+    end
+  end
+
+  # Compute the slice spec for a callable from its keyword parameter list.
+  #
+  # Returns one of:
+  #   - `:keyrest`         the callable accepts `**`, pass the full ctx
+  #   - `:none`            the callable accepts nothing, pass nil
+  #   - `Array<Symbol>`    the kw arg names to slice from the ctx
+  #
+  # @api private
+  def self.compute_parameter_spec(callable:)
+    parameters = get_parameters(callable:)
+    by_type    = parameters.group_by { |el| el[0] }
+
+    if (by_type.keys - [:keyreq, :key, :keyrest]).size > 0
+      raise FlowOrganizer::Error.new('FlowOrganizer only supports methods with keyword arguments')
+    end
+
+    if by_type[:keyrest]
+      :keyrest
+    elsif by_type[:keyreq] || by_type[:key]
+      ((by_type[:keyreq] || []).map { |el| el[1] }) + ((by_type[:key] || []).map { |el| el[1] })
+    else
+      :none
+    end
+  end
+
+  # Memoized `callable => slice_spec` map. Method/Proc objects with identical
+  # signatures hash and compare equal, so they collapse to one cache entry.
+  #
+  # @api private
+  def self.parameter_cache
+    @parameter_cache ||= {}
+  end
+
+  # Drops every cached parameter spec. Useful for tests, benchmarks, and code
+  # reloading scenarios where stale Method objects should not be retained.
+  def self.clear_parameter_cache
+    @parameter_cache = {}
+  end
+
+end

data/lib/flow_organizer/error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class FlowOrganizer::Error < StandardError
+end

data/lib/flow_organizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FlowOrganizer
+  VERSION = '1.0.0'
+end

data/lib/flow_organizer.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# FlowOrganizer passes the result of a callable to another callable (as long as the result is successfull).
+#
+# It is mostly useful when you need to execute a series of operations ressembling a pipeline.
+#
+# You might alredy be familiar with some solutions that deal with this (Promises, Railway Programming, Pipe operators):
+# `FlowOrganizer` is a flavor of functional interactor.
+#
+# ### Introduction
+# Describing a list of operations often leads to code that is difficult to follow or nested requires a lot of nesting. For instance:
+# ```ruby
+# fire_user_created_event(persist_user(validate_password(validate_email({ email: email, password: password }))))
+#
+# # or
+#
+# valid_email?    = validate_email(email)
+# valid_password? = validate_password(password)
+# if valid_email? && valid_password?
+#   user = persist_user(email: email, password: password)
+#   if user
+#     fire_user_created_event(user: user)
+#   end
+# end
+# ```
+#
+# With `FlowOrganizer`, this is expressed as:
+# ```ruby
+# FlowOrganizer.call(
+#   list: [
+#     [:alias, :validate_email],
+#     [:alias, :validate_password],
+#     [:alias, :persist_user],
+#     [:alias, :fire_user_created_event],
+#   ],
+#   ctx: {
+#     email: '',
+#     password: '',
+#   },
+# )
+# ```
+#
+# #### Context
+# An organizer uses a context. The context contains everything the set of operations need to work.
+# When an operation is called, it can affect the context.
+#
+# #### Callable
+# A callable is expected to return a result tupple of the following format:
+# ```ruby
+# [:ok] || [:ok, context_update] || [:halt] || [:halt, context_update] || [:error] || [:error, context_update]
+# ```
+module FlowOrganizer
+
+  class << self
+    # Optional callback invoked when a callable raises. Signature: `->(exception:) { ... }`.
+    # Wire this to Sentry/Honeybadger/etc. The default is no-op.
+    attr_accessor :exception_reporter
+  end
+
+  # Run a `list` of `operations` (callables) in order.
+  #
+  # Each results update the initial `ctx` which is then sent to the next operation.
+  #
+  # An `operation` needs to be a callable, but it can be resolved from other format (see `#to_callable`)
+  #
+  # NOTE: Every operation is expected to return a tupple of the format `[:ok]` or `[:error]` with an optional context update (`[:ok, { new_ctx_key: 'value' }]`, `[:errors, { errors: [{ detail: 'Error explaination' }], }]`). If an `:error` tupple is returned, the next operations are canceled and `call` will return.
+  #
+  # @param list An array of operations (callables) that will be called in order
+  # @param ctx A hash containing values to send to the operations (callables). It will be updated after every operation.
+  # @return The updated context.
+  def self.call(list:, list_error: nil, ctx: nil, raise_exception: false)
+    ctx        = (ctx || {}).dup
+    list_error = [] unless list_error.is_a?(Array)
+
+    status, ctx = call_list(list, :ok, ctx, raise_exception)
+
+    # If there is an error on the "success" track (list), switch to the "error" track, (list_error)
+    if status == :error
+      status, ctx = call_list(list_error, status, ctx, raise_exception)
+    end
+
+    status = :ok if status == :halt
+
+    [status, ctx]
+  end
+
+  def self.call_list(list, status, ctx, raise_exception)
+    list.each do |el|
+      # Inline fast path for raw callables — skip the resolver allocation.
+      if el.respond_to?(:call)
+        callable = el
+      else
+        _, resolved = FlowOrganizer::Callable.resolve(target: el)
+        callable    = resolved[:callable]
+      end
+
+      # Generate arguments compatible with what the callable expects
+      local_ctx = FlowOrganizer::Context.generate_callable_ctx(callable: callable, ctx: ctx)
+
+      # Skip the empty `**` splat when the callable takes no kwargs.
+      result = local_ctx.nil? ? callable.call : callable.call(**local_ctx)
+      status, local_ctx = result
+
+      # `sanitize_errors` is a no-op on `:ok` — only call when it might do work.
+      if status == :error
+        result = sanitize_errors(result)
+        _, local_ctx = result
+      end
+
+      # Mutate ctx in place (we own it — `call` dup'd it) and skip when nothing to merge.
+      if local_ctx && !local_ctx.empty?
+        FlowOrganizer::Context.update_context!(ctx: ctx, local_ctx: local_ctx)
+      end
+
+      # Stop execution status is not `:ok`
+      break if status == :error || status == :halt
+    rescue StandardError => e
+      status      = :error
+      ctx[:error] = e
+
+      if raise_exception
+        raise e
+      else
+        exception_reporter&.call(exception: e)
+      end
+
+      break
+    end
+
+    [status, ctx]
+  end
+
+  # Sanitizes returned errors, if any.
+  #
+  # @api private
+  # @note Enable simpler error return format from an organized callable.
+  #
+  # @example Returning an error as a string
+  #    sanitize_result([:error, 'Error details']) => [:error, { errors: [{ detail: 'Error details' }] }]
+  # @example Returning an error as hash with detail
+  #    sanitize_result([:error, { detail: 'Error details' }]) => [:error, { errors: [{ detail: 'Error details' }] }]
+  # @example Returning an array of errors in the two former formats
+  #    sanitize_result([:error, ['Error1 detail', { detail: 'Error2 details' }]) => [:error, { errors: [{ detail: 'Error1 details' }, { detail: 'Error2 details' }] }]
+  def self.sanitize_errors(result)
+    status, ctx = result
+
+    return result if status != :error
+
+    case ctx
+    when String
+      ctx = { errors: [{ title: ctx }] }
+    when Hash
+      if !ctx[:errors]
+        if ctx[:title] || ctx[:detail] || ctx[:code]
+          ctx = { errors: [ctx] }
+        elsif ctx[:error]
+          ctx = { errors: [ctx[:error]] }
+        end
+      end
+    when Array
+      ctx = { errors: ctx.map { |el| (el.is_a?(String)) ? { title: el } : el } }
+    end
+
+    [status, ctx]
+  end
+
+end
+
+require_relative 'flow_organizer/version'
+require_relative 'flow_organizer/error'
+require_relative 'flow_organizer/context'
+require_relative 'flow_organizer/callable'
+require_relative 'flow_organizer/callable/alias'
+require_relative 'flow_organizer/callable/branch'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: flow_organizer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nathan Appere
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: |
+  FlowOrganizer runs a list of callables (lambdas, methods, anything responding to #call)
+  in sequence, threading a context hash through each step. Inspired by Railway
+  Programming / Promise chains / functional interactors.
+email:
+- nathan.appere@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/flow_organizer.rb
+- lib/flow_organizer/callable.rb
+- lib/flow_organizer/callable/alias.rb
+- lib/flow_organizer/callable/branch.rb
+- lib/flow_organizer/context.rb
+- lib/flow_organizer/error.rb
+- lib/flow_organizer/version.rb
+homepage: https://github.com/nathan-appere/ruby-flow-organizer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/nathan-appere/ruby-flow-organizer
+  bug_tracker_uri: https://github.com/nathan-appere/ruby-flow-organizer/issues
+  changelog_uri: https://github.com/nathan-appere/ruby-flow-organizer/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: 'Functional interactor: run a list of callables in a pipeline with shared
+  context.'
+test_files: []