philiprehberger-assert 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c31f52ec0931f246b6319415cd94403637975101e7072556cd1b527ce306b02
+  data.tar.gz: ceb55d858cdfcff1a456f6bd3a95ded5ff1c43e44a4b6b0da7eaf16cbb043bb0
+SHA512:
+  metadata.gz: 19fee319b29dfa793a3f6925b3a222195b1b35685faecd98f9b3047b232a4bc726444ae1b41adea18733550f309296d9938b8328a2c0d50babcf1c0dd44fc6fa
+  data.tar.gz: c517317adb20571513cb20cfe770ebb767a8484a3b809e6955f73f2b25f80d1f2567bec611eb1401902e0b218173124125ed8909b8f3dab437e478d4cbff37d4

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# 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 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-15
+
+### Added
+- Initial release
+- Chainable assertion matchers
+- Soft assertions collecting all failures
+- Precondition/postcondition helpers
+- Type comparison and pattern checks

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,105 @@
+# philiprehberger-assert
+
+[![Tests](https://github.com/philiprehberger/rb-assert/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-assert/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-assert.svg)](https://rubygems.org/gems/philiprehberger-assert)
+
+Standalone runtime assertion library with chainable matchers for Ruby.
+
+## Requirements
+
+- Ruby >= 3.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'philiprehberger-assert'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install philiprehberger-assert
+```
+
+## Usage
+
+```ruby
+require 'philiprehberger/assert'
+```
+
+### Basic Assertions
+
+```ruby
+Philiprehberger::Assert.that(42).is_a(Integer)
+Philiprehberger::Assert.that('hello').not_blank.matches(/^hel/)
+```
+
+### Chainable Matchers
+
+```ruby
+Philiprehberger::Assert.that(age).is_a(Integer).gte(0).lte(150)
+Philiprehberger::Assert.that(config).includes_key(:host)
+Philiprehberger::Assert.that(items).not_empty
+```
+
+### Custom Messages
+
+```ruby
+Philiprehberger::Assert.that(value, 'value must be a positive number').is_a(Integer).gt(0)
+```
+
+### Soft Assertions
+
+Collect all failures instead of stopping at the first one:
+
+```ruby
+Philiprehberger::Assert.soft do |a|
+  a.call(name).not_blank
+  a.call(age).is_a(Integer).gte(0)
+  a.call(email).matches(/@/)
+end
+# raises MultipleFailures with all failed assertions
+```
+
+### Preconditions (Design by Contract)
+
+```ruby
+Philiprehberger::Assert.precondition(user.active?, 'user must be active')
+```
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `Assert.that(value, message = nil)` | Start a chainable assertion |
+| `Assert.soft { \|a\| ... }` | Collect failures, raise at end |
+| `Assert.precondition(condition, message)` | Design by Contract check |
+| `Assertion#is_a(type)` | Assert value is an instance of type |
+| `Assertion#gte(num)` | Assert value >= num |
+| `Assertion#lte(num)` | Assert value <= num |
+| `Assertion#gt(num)` | Assert value > num |
+| `Assertion#lt(num)` | Assert value < num |
+| `Assertion#matches(pattern)` | Assert value matches regex pattern |
+| `Assertion#not_blank` | Assert value is not nil or blank |
+| `Assertion#not_empty` | Assert value is not empty |
+| `Assertion#includes_key(key)` | Assert hash includes key |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec      # Run tests
+bundle exec rubocop    # Check code style
+```
+
+## License
+
+MIT

data/lib/philiprehberger/assert/assertion.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module Assert
+    # Chainable assertion object returned by Assert.that.
+    class Assertion
+      def initialize(value, message: nil, failures: nil)
+        @value = value
+        @message = message
+        @failures = failures
+      end
+
+      def is_a(type) # rubocop:disable Naming/PredicatePrefix
+        check(@value.is_a?(type), "Expected #{@value.inspect} to be a #{type}")
+      end
+
+      def gte(num)
+        check(@value >= num, "Expected #{@value.inspect} to be >= #{num}")
+      end
+
+      def lte(num)
+        check(@value <= num, "Expected #{@value.inspect} to be <= #{num}")
+      end
+
+      def gt(num)
+        check(@value > num, "Expected #{@value.inspect} to be > #{num}")
+      end
+
+      def lt(num)
+        check(@value < num, "Expected #{@value.inspect} to be < #{num}")
+      end
+
+      def matches(pattern)
+        check(pattern.match?(@value.to_s), "Expected #{@value.inspect} to match #{pattern.inspect}")
+      end
+
+      def not_blank
+        check(!@value.nil? && !@value.to_s.strip.empty?, 'Expected value to not be blank')
+      end
+
+      def not_empty
+        check(@value.respond_to?(:empty?) && !@value.empty?, 'Expected value to not be empty')
+      end
+
+      def includes_key(key)
+        check(@value.respond_to?(:key?) && @value.key?(key), "Expected #{@value.inspect} to include key #{key.inspect}")
+      end
+
+      private
+
+      def check(condition, default_message)
+        msg = @message || default_message
+        if condition
+          self
+        elsif @failures
+          @failures << msg
+          self
+        else
+          raise AssertionError, msg
+        end
+      end
+    end
+  end
+end

data/lib/philiprehberger/assert/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module Assert
+    # Raised when a single assertion fails.
+    class AssertionError < StandardError; end
+
+    # Raised after a soft assertion block when one or more assertions failed.
+    class MultipleFailures < StandardError
+      attr_reader :messages
+
+      def initialize(messages)
+        @messages = messages
+        super("Multiple assertion failures:\n#{messages.map { |m| "  - #{m}" }.join("\n")}")
+      end
+    end
+  end
+end

data/lib/philiprehberger/assert/version.rb

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

data/lib/philiprehberger/assert.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'assert/version'
+require_relative 'assert/errors'
+require_relative 'assert/assertion'
+
+module Philiprehberger
+  module Assert
+    # Create a chainable assertion for the given value.
+    #
+    # @param value the value to assert against
+    # @param message [String, nil] optional custom failure message
+    # @return [Assertion]
+    def self.that(value, message = nil)
+      Assertion.new(value, message: message)
+    end
+
+    # Collect assertion failures instead of raising immediately.
+    #
+    # @yield [proc] a proc that creates soft assertions
+    # @raise [MultipleFailures] if any assertions failed
+    def self.soft
+      failures = []
+      yield ->(value, message = nil) { Assertion.new(value, message: message, failures: failures) }
+      raise MultipleFailures, failures unless failures.empty?
+    end
+
+    # Design by Contract precondition check.
+    #
+    # @param condition [Boolean] the condition to verify
+    # @param message [String] failure message
+    # @raise [AssertionError] if condition is false
+    def self.precondition(condition, message)
+      raise AssertionError, message unless condition
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: philiprehberger-assert
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Philip Rehberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-15 00:00:00.000000000 Z
+dependencies: []
+description: A lightweight runtime assertion library for Ruby with chainable matchers,
+  soft assertions, and Design by Contract preconditions.
+email:
+- me@philiprehberger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/philiprehberger/assert.rb
+- lib/philiprehberger/assert/assertion.rb
+- lib/philiprehberger/assert/errors.rb
+- lib/philiprehberger/assert/version.rb
+homepage: https://github.com/philiprehberger/rb-assert
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/philiprehberger/rb-assert
+  source_code_uri: https://github.com/philiprehberger/rb-assert
+  changelog_uri: https://github.com/philiprehberger/rb-assert/blob/main/CHANGELOG.md
+  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: Standalone runtime assertion library with chainable matchers
+test_files: []