flowy 0.1.0

data/lib/flowy/result.rb

@@ -0,0 +1,63 @@
+module Flowy
+  # Tag module + factory namespace. Both Flowy::Success and Flowy::Failure
+  # include this module so `result.is_a?(Flowy::Result)` matches either.
+  # The instance interface is defined on Success and Failure — see the README.
+  module Result
+    def self._deep_merge(a, b)
+      a.merge(b) do |_, va, vb|
+        if va.is_a?(Hash) && vb.is_a?(Hash)
+          _deep_merge(va, vb)
+        else
+          vb
+        end
+      end
+    end
+
+    def self._collect_results(enumerable)
+      enumerable.map do |item|
+        result = yield item
+        unless result.is_a?(Flowy::Result)
+          raise TypeError,
+            "all_success/any_success block must return a Flowy::Result, got #{result.class}"
+        end
+        result
+      end
+    end
+
+    def self.success(data: {}, warnings: [])
+      Flowy::Success.new(data: data, warnings: warnings)
+    end
+
+    def self.failure(error_code:, error_data: {}, error_title: nil, error_description: nil, parent_failure: nil)
+      Flowy::Failure.new(
+        error_code: error_code,
+        error_data: error_data,
+        error_title: error_title,
+        error_description: error_description,
+        parent_failure: parent_failure
+      )
+    end
+
+    # `rescue:` is captured via **opts because `rescue` is a Ruby reserved word
+    # and cannot be referenced as a bare local variable inside a method body.
+    def self.wrap(error_code: :wrapped_error, error_title: nil, **opts)
+      unknown = opts.keys - [:rescue]
+      raise ArgumentError, "unknown keyword: #{unknown.first}" if unknown.any?
+
+      rescued_classes = Array(opts.fetch(:rescue, [StandardError]))
+
+      value = yield
+
+      return value if value.is_a?(Flowy::Result)
+
+      Flowy::Success.new(data: { value: value })
+    rescue *rescued_classes => e
+      Flowy::Failure.new(
+        error_code: error_code,
+        error_data: { error_class: e.class.name, message: e.message },
+        error_title: error_title,
+        error_description: e.message
+      )
+    end
+  end
+end

data/lib/flowy/success.rb

@@ -0,0 +1,74 @@
+module Flowy
+  class Success
+    include Flowy::Result
+
+    attr_reader :data, :warnings
+
+    def initialize(data: {}, warnings: [])
+      @data = data
+      @warnings = warnings
+    end
+
+    def +(other)
+      self.class.new(data: Flowy::Result._deep_merge(data, other.data))
+    end
+
+    def to_hash
+      {
+        success: true,
+        data: data,
+        warnings: warnings
+      }
+    end
+
+    def success?
+      true
+    end
+
+    def failure?
+      false
+    end
+
+    def on_success
+      yield self
+      self
+    end
+
+    def on_failure
+      self
+    end
+
+    def and_then
+      result = yield self
+      unless result.is_a?(Flowy::Success) || result.is_a?(Flowy::Failure)
+        raise TypeError, "and_then block must return a Flowy::Success or Flowy::Failure, got #{result.class}"
+      end
+
+      result
+    end
+
+    def or_else
+      self
+    end
+
+    def map_failure(**)
+      self
+    end
+
+    def raise!
+      self
+    end
+
+    def tap
+      yield self
+      self
+    end
+
+    def merge_data(extra = nil)
+      extra = block_given? ? yield(data) : extra
+      raise ArgumentError, 'merge_data requires a Hash' unless extra.is_a?(Hash)
+
+      self.class.new(data: Flowy::Result._deep_merge(data, extra), warnings: warnings)
+    end
+  end
+end

data/lib/flowy/version.rb

@@ -0,0 +1,3 @@
+module Flowy
+  VERSION = '0.1.0'
+end

data/lib/flowy.rb

@@ -0,0 +1,11 @@
+require 'flowy/version'
+require 'flowy/result'
+require 'flowy/success'
+require 'flowy/failure'
+require 'flowy/error'
+require 'flowy/concern'
+require 'flowy/enumerable'
+require 'flowy/pipeline'
+
+module Flowy
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: flowy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leanbit
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-25 00:00:00.000000000 Z
+dependencies:
+- !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: Flowy provides Success/Failure result objects and a composable step-based
+  concern for clean, functional-style service objects in Ruby.
+email:
+- support@leanbit.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/flowy.rb
+- lib/flowy/concern.rb
+- lib/flowy/concern/step_runner.rb
+- lib/flowy/enumerable.rb
+- lib/flowy/error.rb
+- lib/flowy/failure.rb
+- lib/flowy/pipeline.rb
+- lib/flowy/result.rb
+- lib/flowy/success.rb
+- lib/flowy/version.rb
+homepage: https://github.com/leanbit/flowy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+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: 3.4.20
+signing_key:
+specification_version: 4
+summary: Lightweight Railway Oriented Programming for Ruby
+test_files: []