philiprehberger-try 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 40ddecd021c85d699464539a71ffa8744a3638e6988a1e1dec760347e838a9b2
+  data.tar.gz: f411a171dceece62cbe7c860e042a91dbb1f18d06e5d4bccbb24b67e127e81f2
+SHA512:
+  metadata.gz: e56704dcff5128983d1f762c40c93313ec789a311047b746c0b76c038f6c975d793c19c80d70b60ed7d361e1b7fd7d93a51115e5d34ced8097ed36854ea8d699
+  data.tar.gz: 119a1a224d8cc61d6077ffaef468a62a717a9c5e39081ca021e6831c544f605f06944233091279d4e8088a9fc530ef16e099b58001a9b9f72a0ca6af7c677ba5

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this gem adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-21
+
+### Added
+- Initial release
+- `Try.call` for wrapping risky expressions
+- `Success` and `Failure` result types
+- `.or_else` for default values on failure
+- `.or_try` for chained recovery attempts
+- `.on(ExceptionClass)` for specific error handling
+- `.on_error` for failure side effects
+- `.map` for transforming success values
+- Optional timeout support

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 philiprehberger
+
+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,147 @@
+# philiprehberger-try
+
+[![Tests](https://github.com/philiprehberger/rb-try/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-try/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-try.svg)](https://rubygems.org/gems/philiprehberger-try)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Concise error handling with fallbacks, chained recovery, and timeout wrapping
+
+## Requirements
+
+- Ruby >= 3.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "philiprehberger-try"
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+Or install directly:
+
+```sh
+gem install philiprehberger-try
+```
+
+## Usage
+
+```ruby
+require "philiprehberger/try"
+```
+
+### Basic wrapping
+
+Wrap any risky expression with `Try.call`. It returns a `Success` or `Failure`:
+
+```ruby
+result = Philiprehberger::Try.call { Integer("42") }
+result.success? # => true
+result.value    # => 42
+
+result = Philiprehberger::Try.call { Integer("nope") }
+result.failure? # => true
+result.error    # => #<ArgumentError: invalid value for Integer(): "nope">
+```
+
+### Default values with `or_else`
+
+Provide a fallback value when the operation fails:
+
+```ruby
+value = Philiprehberger::Try.call { Integer("nope") }
+  .or_else(0)
+  .value
+
+value # => 0
+```
+
+### Chained recovery with `or_try`
+
+Chain multiple recovery strategies. The first success wins:
+
+```ruby
+result = Philiprehberger::Try
+  .call { fetch_from_cache(key) }
+  .or_try { fetch_from_database(key) }
+  .or_try { fetch_from_api(key) }
+
+result.value! # returns the first successful result or raises
+```
+
+### Handling specific exceptions with `on`
+
+Recover from specific exception types:
+
+```ruby
+result = Philiprehberger::Try.call { parse_config(path) }
+  .on(Errno::ENOENT) { |_e| default_config }
+  .on(JSON::ParserError) { |e| raise ConfigError, "Invalid JSON: #{e.message}" }
+```
+
+### Side effects with `on_error`
+
+Log or report errors without changing the result:
+
+```ruby
+result = Philiprehberger::Try.call { risky_operation }
+  .on_error { |e| logger.warn("Operation failed: #{e.message}") }
+  .or_else(fallback)
+```
+
+### Transforming values with `map`
+
+Transform a successful value. Failures propagate unchanged:
+
+```ruby
+result = Philiprehberger::Try.call { File.read("data.json") }
+  .map { |contents| JSON.parse(contents) }
+  .map { |data| data.fetch("key") }
+
+result.value # => parsed value or nil if any step failed
+```
+
+### Timeout support
+
+Add a timeout constraint to any operation:
+
+```ruby
+result = Philiprehberger::Try.call(timeout: 5) { slow_http_request }
+
+result.failure? # => true if it took longer than 5 seconds
+result.error    # => #<Timeout::Error: execution expired>
+```
+
+## API
+
+| Method | On Success | On Failure |
+|---|---|---|
+| `Try.call(timeout: nil) { block }` | Returns `Success` wrapping block result | Returns `Failure` wrapping exception |
+| `#value` | Returns the wrapped value | Returns `nil` |
+| `#value!` | Returns the wrapped value | Raises the stored exception |
+| `#success?` | `true` | `false` |
+| `#failure?` | `false` | `true` |
+| `#error` | N/A | Returns the stored exception |
+| `#or_else(default)` | Returns self | Returns `Success.new(default)` |
+| `#or_try { block }` | Returns self | Calls `Try.call` with the block |
+| `#on(ExceptionClass) { block }` | Returns self | If error matches, returns `Try.call { block }` |
+| `#on_error { block }` | Returns self | Calls block for side effect, returns self |
+| `#map { block }` | Wraps block result in new `Try.call` | Returns self |
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

data/lib/philiprehberger/try/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module Try
+    VERSION = '0.1.0'
+  end
+end

data/lib/philiprehberger/try.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require_relative 'try/version'
+
+module Philiprehberger
+  module Try
+    def self.call(timeout: nil)
+      value = if timeout
+                Timeout.timeout(timeout) { yield }
+              else
+                yield
+              end
+      Success.new(value)
+    rescue StandardError => e
+      Failure.new(e)
+    end
+
+    class Success
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        freeze
+      end
+
+      def value!
+        @value
+      end
+
+      def success?
+        true
+      end
+
+      def failure?
+        false
+      end
+
+      def or_else(_default)
+        self
+      end
+
+      def or_try
+        self
+      end
+
+      def on(_exception_class)
+        self
+      end
+
+      def on_error
+        self
+      end
+
+      def map
+        Try.call { yield @value }
+      end
+    end
+
+    class Failure
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+        freeze
+      end
+
+      def value
+        nil
+      end
+
+      def value!
+        raise @error
+      end
+
+      def success?
+        false
+      end
+
+      def failure?
+        true
+      end
+
+      def or_else(default)
+        Success.new(default)
+      end
+
+      def or_try(&block)
+        Try.call(&block)
+      end
+
+      def on(exception_class, &block)
+        return Try.call { block.call(@error) } if @error.is_a?(exception_class)
+
+        self
+      end
+
+      def on_error
+        yield @error
+        self
+      end
+
+      def map
+        self
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: philiprehberger-try
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Philip Rehberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-22 00:00:00.000000000 Z
+dependencies: []
+description: A tiny utility for concise error handling. Wrap risky expressions with
+  Try.call, chain fallbacks with or_else and or_try, handle specific exceptions, and
+  add timeout constraints — all without verbose begin/rescue blocks.
+email:
+- me@philiprehberger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/philiprehberger/try.rb
+- lib/philiprehberger/try/version.rb
+homepage: https://github.com/philiprehberger/rb-try
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/philiprehberger/rb-try
+  source_code_uri: https://github.com/philiprehberger/rb-try
+  changelog_uri: https://github.com/philiprehberger/rb-try/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/philiprehberger/rb-try/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Concise error handling with fallbacks, chained recovery, and timeout wrapping
+test_files: []