fix 0.21 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a61d6e74ba8d919c935036f602b4ac3bdf4ec121a9880cb6168d16893384e194
-  data.tar.gz: 1060db9d560d9288af75686c51bf6acbc38fb29606b3d451493f39548795744f
+  metadata.gz: 3f307018b701019985c925b9a244c7b6813462faac51b8fef26488070a564f30
+  data.tar.gz: c09cc676e5394ef581f5fa7d0ae57beafc4a28686661c5d66b0bdd0006481864
 SHA512:
-  metadata.gz: 19f6f8612289b9e23bcda11fd20ee039591a8270b1dbec962474261f45e72784ed6e4ab414ecb2e13280095ca349017eb56c3076f4bddf8bc1b5144a44a6880a
-  data.tar.gz: 1a8a4b2181814fbd064559a726cd7a41f6fa1079c9f58fc8babc4d54f539ead621ede997a24754e404e5dc64a37a2e138db07e52df1a9bfb9c6d8c939815abcd
+  metadata.gz: 35d0e3bafa2f2b612a039c9892cf6024eb42bc52923a551c49b96d3b0efb2abcd9a6e5022b8086c69c351e15f5b789f460e2c938b1a82a4f7148c18a93ca4898
+  data.tar.gz: 9c6b388b420a98226aeb4fb59746725f4ea36824ea0d78065b01c4bd9d7c341a10b84dcb42351ca6a0bf865bf754404ad263cfd2b29de1cdd5916e97fd89fbf5

data/LICENSE.md

@@ -1,6 +1,6 @@
-# The MIT License
+The MIT License (MIT)
 
-Copyright (c) 2014-2025 Cyril Kato
+Copyright (c) 2014-2020 Cyril Kato
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,452 +1,119 @@
-# Fix Framework
+# Fix
 
-[![Home](https://img.shields.io/badge/Home-fixrb.dev-00af8b)](https://fixrb.dev/)
-[![Version](https://img.shields.io/github/v/tag/fixrb/fix?label=Version&logo=github)](https://github.com/fixrb/fix/tags)
-[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/fixrb/fix/main)
-[![License](https://img.shields.io/github/license/fixrb/fix?label=License&logo=github)](https://github.com/fixrb/fix/raw/main/LICENSE.md)
+[![Build Status](https://api.travis-ci.org/fixrb/fix.svg?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/fixrb/fix/badges/gpa.svg)][codeclimate]
+[![Gem Version](https://badge.fury.io/rb/fix.svg)][gem]
+[![Inline docs](https://inch-ci.org/github/fixrb/fix.svg?branch=master)][inchpages]
+[![Documentation](https://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 
-## Introduction
-
-Fix is a modern Ruby testing framework that emphasizes clear separation between specifications and examples. Unlike traditional testing frameworks, Fix focuses on creating pure specification documents that define expected behaviors without mixing in implementation details.
+> Specing framework for Ruby.
 
 ## Installation
 
-### Prerequisites
-
-- Ruby >= 3.1.0
-
-### Setup
-
-Add to your Gemfile:
-
-```ruby
-gem "fix"
-```
-
-Then execute:
-
-```sh
-bundle install
-```
-
-Or install it yourself:
-
-```sh
-gem install fix
-```
-
-## Core Principles
-
-- **Specifications vs Examples**: Fix makes a clear distinction between specifications (what is expected) and examples (how it's demonstrated). This separation leads to cleaner, more maintainable test suites.
-
-- **Logic-Free Specifications**: Your specification documents remain pure and focused on defining behaviors, without getting cluttered by implementation logic.
-
-- **Rich Semantic Language**: Following RFC 2119 conventions, Fix uses precise language with keywords like MUST, SHOULD, and MAY to clearly define different requirement levels in specifications.
-
-- **Fast Individual Testing**: Tests execute quickly and independently, providing rapid feedback on specification compliance.
-
-## Framework Features
-
-### Property Definition with `let`
-
-Define reusable properties across your specifications:
-
-```ruby
-Fix do
-  let(:name) { "Bob" }
-  let(:age) { 42 }
-
-  it MUST eq name
-end
-```
-
-### Context Creation with `with`
-
-Test behavior under different conditions:
+Add this line to your application's Gemfile:
 
 ```ruby
-Fix do
-  with name: "Alice", role: "admin" do
-    it MUST be_allowed
-  end
-
-  with name: "Bob", role: "guest" do
-    it MUST_NOT be_allowed
-  end
-end
+gem 'fix', '>= 1.0.0.beta1'
 ```
 
-### Method Testing with `on`
+And then execute:
 
-Test how objects respond to specific messages:
+    $ bundle
 
-```ruby
-Fix do
-  on :upcase do
-    it MUST eq "HELLO"
-  end
+Or install it yourself as:
 
-  on :+, 2 do
-    it MUST eq 42
-  end
-end
-```
+    $ gem install fix --pre
 
-### Requirement Levels
+## Usage
 
-Fix provides three levels of requirements, each with clear semantic meaning:
-
-- **MUST/MUST_NOT**: Absolute requirements or prohibitions
-- **SHOULD/SHOULD_NOT**: Recommended practices with valid exceptions
-- **MAY**: Optional features
+Given this app:
 
 ```ruby
-Fix do
-  it MUST be_valid           # Required
-  it SHOULD be_optimized     # Recommended
-  it MAY include_metadata    # Optional
-end
-```
-
-## Quick Start
-
-Create your first test file:
-
-```ruby
-# first_test.rb
-require "fix"
-
-Fix :HelloWorld do
-  it MUST eq "Hello, World!"
-end
-
-Fix[:HelloWorld].test { "Hello, World!" }
-```
-
-Run it:
-
-```sh
-ruby first_test.rb
-```
-
-## Real-World Examples
-
-Fix is designed to work with real-world applications of any complexity. Here are some examples demonstrating how Fix can be used in different scenarios:
-
-### Example 1: User Account Management
-
-Here's a comprehensive example showing how to specify a user account system:
-
-```ruby
-Fix :UserAccount do
-  # Define reusable properties
-  let(:admin) { User.new(role: "admin") }
-  let(:guest) { User.new(role: "guest") }
-
-  # Test basic instance properties
-  it MUST be_an_instance_of User
-
-  # Test with different contexts
-  with role: "admin" do
-    it MUST be_admin
-
-    on :can_access?, "settings" do
-      it MUST be_true
-    end
-  end
-
-  with role: "guest" do
-    it MUST_NOT be_admin
-
-    on :can_access?, "settings" do
-      it MUST be_false
-    end
+# examples/duck/app.rb
+class Duck
+  def walks
+    'Klop klop!'
   end
 
-  # Test specific methods
-  on :full_name do
-    with first_name: "John", last_name: "Doe" do
-      it MUST eq "John Doe"
-    end
+  def swims
+    'Swoosh...'
   end
 
-  on :update_password, "new_password" do
-    it MUST change(admin, :password_hash)
-    it MUST be_true  # Return value check
+  def quacks
+    puts 'Quaaaaaack!'
   end
 end
 ```
 
-The implementation might look like this:
+When you run this:
 
 ```ruby
-class User
-  attr_reader :role, :password_hash
+# examples/duck/fix.rb
+require_relative 'app'
+require_relative '../../lib/fix'
 
-  def initialize(role:)
-    @role = role
-    @password_hash = nil
-  end
-
-  def admin?
-    role == "admin"
-  end
-
-  def can_access?(resource)
-    return true if admin?
-    false
-  end
-
-  def full_name
-    "#{@first_name} #{@last_name}"
-  end
-
-  def update_password(new_password)
-    @password_hash = Digest::SHA256.hexdigest(new_password)
-    true
-  end
-end
-```
-
-### Example 2: Duck Specification
-
-Here's how Fix can be used to specify a Duck class:
-
-```ruby
-Fix :Duck do
-  it SHOULD be_an_instance_of :Duck
+@bird = Duck.new
 
+Fix(@bird) do
   on :swims do
-    it MUST be_an_instance_of :String
-    it MUST eql "Swoosh..."
+    it { MUST eql 'Swoosh...' }
   end
 
   on :speaks do
-    it MUST raise_exception NoMethodError
+    it { MUST raise_exception NoMethodError }
   end
 
   on :sings do
-    it MAY eql "♪... ♫..."
+    it { MAY eql '♪... ♫...' }
   end
 end
 ```
 
-The implementation:
+Then the output should look like this:
 
-```ruby
-class Duck
-  def walks
-    "Klop klop!"
-  end
-
-  def swims
-    "Swoosh..."
-  end
-
-  def quacks
-    puts "Quaaaaaack!"
-  end
-end
-```
-
-Running the test:
-
-```ruby
-Fix[:Duck].test { Duck.new }
+```sh
+ruby examples/duck/fix.rb
 ```
-## Available Matchers
-
-Fix includes a comprehensive set of matchers through its integration with the [Matchi library](https://github.com/fixrb/matchi):
-
-<details>
-<summary><strong>Basic Comparison Matchers</strong></summary>
-
-- `eq(expected)` - Tests equality using `eql?`
-  ```ruby
-  it MUST eq(42)                   # Passes if value.eql?(42)
-  it MUST eq("hello")              # Passes if value.eql?("hello")
-  ```
-- `eql(expected)` - Alias for eq
-- `be(expected)` - Tests object identity using `equal?`
-  ```ruby
-  string = "test"
-  it MUST be(string)               # Passes only if it's exactly the same object
-  ```
-- `equal(expected)` - Alias for be
-</details>
-
-<details>
-<summary><strong>Type Checking Matchers</strong></summary>
-
-- `be_an_instance_of(class)` - Verifies exact class match
-  ```ruby
-  it MUST be_an_instance_of(Array) # Passes if value.instance_of?(Array)
-  it MUST be_an_instance_of(User)  # Passes if value.instance_of?(User)
-  ```
-- `be_a_kind_of(class)` - Checks class inheritance and module inclusion
-  ```ruby
-  it MUST be_a_kind_of(Enumerable) # Passes if value.kind_of?(Enumerable)
-  it MUST be_a_kind_of(Animal)     # Passes if value inherits from Animal
-  ```
-</details>
-
-<details>
-<summary><strong>Change Testing Matchers</strong></summary>
-
-- `change(object, method)` - Base matcher for state changes
-  - `.by(n)` - Expects exact change by n
-    ```ruby
-    it MUST change(user, :points).by(5)          # Exactly +5 points
-    ```
-  - `.by_at_least(n)` - Expects minimum change by n
-    ```ruby
-    it MUST change(counter, :value).by_at_least(10)  # At least +10
-    ```
-  - `.by_at_most(n)` - Expects maximum change by n
-    ```ruby
-    it MUST change(account, :balance).by_at_most(100) # No more than +100
-    ```
-  - `.from(old).to(new)` - Expects change from old to new value
-    ```ruby
-    it MUST change(user, :status).from("pending").to("active")
-    ```
-  - `.to(new)` - Expects change to new value
-    ```ruby
-    it MUST change(post, :title).to("Updated")
-    ```
-</details>
-
-<details>
-<summary><strong>Numeric Matchers</strong></summary>
-
-- `be_within(delta).of(value)` - Tests if a value is within ±delta of expected value
-  ```ruby
-  it MUST be_within(0.1).of(3.14)  # Passes if value is between 3.04 and 3.24
-  it MUST be_within(5).of(100)     # Passes if value is between 95 and 105
-  ```
-</details>
-
-<details>
-<summary><strong>Pattern Matchers</strong></summary>
-
-- `match(regex)` - Tests string against regular expression pattern
-  ```ruby
-  it MUST match(/^\d{3}-\d{2}-\d{4}$/)  # SSN format
-  it MUST match(/^[A-Z][a-z]+$/)        # Capitalized word
-  ```
-- `satisfy { |value| ... }` - Custom matching with block
-  ```ruby
-  it MUST satisfy { |num| num.even? && num > 0 }
-  it MUST satisfy { |user| user.valid? && user.active? }
-  ```
-</details>
-
-<details>
-<summary><strong>Exception Matchers</strong></summary>
-
-- `raise_exception(class)` - Tests if code raises specified exception
-  ```ruby
-  it MUST raise_exception(ArgumentError)
-  it MUST raise_exception(CustomError, "specific message")
-  ```
-</details>
-
-<details>
-<summary><strong>State Matchers</strong></summary>
-
-- `be_true` - Tests for true
-  ```ruby
-  it MUST be_true          # Only passes for true, not truthy values
-  ```
-- `be_false` - Tests for false
-  ```ruby
-  it MUST be_false         # Only passes for false, not falsey values
-  ```
-- `be_nil` - Tests for nil
-  ```ruby
-  it MUST be_nil           # Passes only for nil
-  ```
-</details>
-
-<details>
-<summary><strong>Dynamic Predicate Matchers</strong></summary>
-
-- `be_*` - Dynamically matches `object.*?` method
-  ```ruby
-  it MUST be_empty         # Calls empty?
-  it MUST be_valid         # Calls valid?
-  it MUST be_frozen        # Calls frozen?
-  ```
-- `have_*` - Dynamically matches `object.has_*?` method
-  ```ruby
-  it MUST have_key(:id)    # Calls has_key?
-  it MUST have_errors      # Calls has_errors?
-  it MUST have_permission  # Calls has_permission?
-  ```
-</details>
-
-### Complete Example
-
-Here's an example using various matchers together:
 
-```ruby
-Fix :Calculator do
-  it MUST be_an_instance_of Calculator
-
-  on :add, 2, 3 do
-    it MUST eq 5
-    it MUST be_within(0.001).of(5.0)
-  end
-
-  on :divide, 1, 0 do
-    it MUST raise_exception ZeroDivisionError
-  end
-
-  with numbers: [1, 2, 3] do
-    it MUST_NOT be_empty
-    it MUST satisfy { |result| result.all? { |n| n.positive? } }
-  end
-
-  with string_input: "123" do
-    on :parse do
-      it MUST be_a_kind_of Numeric
-      it MUST satisfy { |n| n > 0 }
-    end
-  end
-end
+```txt
+examples/duck/fix.rb:8: Success: expected to eql "Swoosh...".
+examples/duck/fix.rb:12: Success: undefined method `speaks' for #<Duck:0x00007fe3be868ea0>.
+examples/duck/fix.rb:16: NoMethodError: undefined method `sings' for #<Duck:0x00007fe3be868ea0>.
 ```
 
-## Why Choose Fix?
-
-Fix brings several unique advantages to Ruby testing that set it apart from traditional testing frameworks:
+## Contact
 
-- **Clear Separation of Concerns**: Keep your specifications clean and your examples separate
-- **Semantic Precision**: Express requirements with different levels of necessity
-- **Fast Execution**: Get quick feedback on specification compliance
-- **Pure Specifications**: Write specification documents that focus on behavior, not implementation
-- **Rich Matcher Library**: Comprehensive set of matchers for different testing needs
-- **Modern Ruby**: Takes advantage of modern Ruby features and practices
+* Home page: https://fixrb.dev/
+* Bugs/issues: https://github.com/fixrb/fix/issues
+* Support: https://stackoverflow.com/questions/tagged/fixrb
 
-## Get Started
+## Rubies
 
-Ready to write better specifications? Visit our [GitHub repository](https://github.com/fixrb/fix) to start using Fix in your Ruby projects.
-
-## Community & Resources
-
-- [Blog](https://fixrb.dev/) - Related articles
-- [Bluesky](https://bsky.app/profile/fixrb.dev) - Latest updates and discussions
-- [Documentation](https://www.rubydoc.info/gems/fix) - Comprehensive guides and API reference
-- [Source Code](https://github.com/fixrb/fix) - Contribute and report issues
-- [asciinema](https://asciinema.org/~fix) - Watch practical examples in action
+* [MRI](https://www.ruby-lang.org/)
+* [Rubinius](https://rubinius.com/)
+* [JRuby](https://www.jruby.org/)
 
 ## Versioning
 
-__Fix__ follows [Semantic Versioning 2.0](https://semver.org/).
+__Fix__ follows [Semantic Versioning 2.0](http://semver.org/).
 
 ## License
 
-The [gem](https://rubygems.org/gems/fix) is available as open source under the terms of the [MIT License](https://github.com/fixrb/fix/raw/main/LICENSE.md).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+***
 
-## Sponsors
+<p>
+  This project is sponsored by:<br />
+  <a href="https://sashite.com/"><img
+    src="https://github.com/fixrb/fix/raw/master/img/sashite.png"
+    alt="Sashite" /></a>
+</p>
 
-This project is sponsored by [Sashité](https://sashite.com/)
+[travis]: https://travis-ci.org/fixrb/fix
+[codeclimate]: https://codeclimate.com/github/fixrb/fix
+[gem]: https://rubygems.org/gems/fix
+[inchpages]: http://inch-ci.org/github/fixrb/fix
+[rubydoc]: http://rubydoc.info/gems/fix/frames
+[gitter]: https://gitter.im/fixrb/fix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge

data/lib/fix/context.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'aw'
+require 'defi'
+
+module Fix
+  # Wraps the target of challenge.
+  class Context
+    RESERVED_KEYWORDS = %i[
+      alias
+      and
+      begin
+      break
+      case
+      catch
+      class
+      def
+      defined?
+      do
+      else
+      elsif
+      end
+      ensure
+      fail
+      false
+      for
+      if
+      in
+      module
+      next
+      nil
+      not
+      or
+      raise
+      redo
+      rescue
+      retry
+      return
+      self
+      super
+      then
+      throw
+      true
+      undef
+      unless
+      until
+      when
+      while
+      yield
+    ].freeze
+
+    attr_reader :callable
+
+    def initialize(subject, challenge, before_hooks_counter = 0, *hooks, **lets)
+      @subject      = subject
+      @callable     = challenge.to(subject)
+      @before_hooks = hooks[0, before_hooks_counter]
+      @after_hooks  = hooks[before_hooks_counter..-1]
+      @lets         = lets
+    end
+
+    def before(&block)
+      @before_hooks << block
+    end
+
+    def after(&block)
+      @after_hooks << block
+    end
+
+    def let(name, &block)
+      raise ::TypeError, "expected a Symbol, got #{name.class}" unless name.is_a?(::Symbol)
+      raise ::NameError, "wrong method name `#{name}'" unless name.match?(/\A[a-z][a-z0-9_]+[?!]?\z/)
+      raise ::NameError, "reserved keyword name `#{name}'" if RESERVED_KEYWORDS.include?(name)
+      raise ::NameError, "reserved method name `#{name}'" if respond_to?(name, true) && !@lets.key?(name)
+
+      @lets.update(name => block.call)
+    rescue ::SystemExit => e
+      raise SuspiciousSuccessError, "attempt `#{name}' to bypass the tests" if e.success?
+      raise e
+    end
+
+    def let!(name, &block)
+      raise ::TypeError, "expected a Symbol, got #{name.class}" unless name.is_a?(::Symbol)
+      raise ::NameError, "wrong method name `#{name}'" unless name.match?(/\A[a-z][a-z0-9_]+[?!]?\z/)
+      raise ::NameError, "reserved keyword name `#{name}'" if RESERVED_KEYWORDS.include?(name)
+      raise ::NameError, "reserved method name `#{name}'" if respond_to?(name, true) && !@lets.key?(name)
+
+      @lets.update(name => ::Aw.fork! { block.call })
+    rescue ::SystemExit => e
+      raise SuspiciousSuccessError, "attempt `#{name}' to bypass the tests" if e.success?
+      raise e
+    end
+
+    # Verify the expectation.
+    #
+    # @param block [Proc] A spec to compare against the computed actual value.
+    #
+    # @return [::Spectus::Result::Pass, ::Spectus::Result::Fail] Pass or fail.
+    def it(_message = nil, &block)
+      print "#{block.source_location.join(':')}: "
+      i = It.new(callable, **@lets)
+      @before_hooks.each { |hook| i.instance_eval(&hook) }
+      result = i.instance_eval(&block)
+      puts result.colored_string
+    rescue ::Spectus::Result::Fail => result
+      abort result.colored_string
+    ensure
+      @after_hooks.each { |hook| i.instance_eval(&hook) }
+      raise ExpectationResultNotFoundError unless result.is_a?(::Spectus::Result::Common)
+    end
+
+    def on(name, *args, **options, &block)
+      if callable.raised?
+        actual    = callable
+        challenge = ::Defi.send(:call)
+      else
+        actual    = callable.object
+        challenge = ::Defi.send(name, *args, **options)
+      end
+
+      o = Context.new(actual, challenge, @before_hooks.length, *@before_hooks + @after_hooks, **@lets)
+      o.instance_eval(&block)
+    end
+
+    def with(_message = nil, **new_lets, &block)
+      actual    = callable.object
+      challenge = ::Defi.send(:itself)
+
+      c = Context.new(actual, challenge, @before_hooks.length, *@before_hooks + @after_hooks, **@lets.merge(new_lets))
+      c.instance_eval(&block)
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      @lets.fetch(name) { super }
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @lets.key?(name) || super
+    end
+  end
+end
+
+require_relative 'it'
+require_relative 'expectation_result_not_found_error'
+require_relative 'suspicious_success_error'

data/lib/fix/expectation_result_not_found_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fix
+  class ExpectationResultNotFoundError < ::RuntimeError; end
+end