matchi 5.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66ca7f8e6eb1fb3e7fa80907957f37af41fd04b678258199c0f1abfe784aa839
-  data.tar.gz: b25bc8c4da4bb7db33478cf7fda77e7119bf0fce94fdfd8310ab8d7c79f8638c
+  metadata.gz: 5f6e92545e779fe4ef4a899d77213b30b26480bb4ee4daef969b1e1ea60ee7e5
+  data.tar.gz: a407ea85374dd3242d28da5609fe37320200879edb46c877a13dba1f3e377d66
 SHA512:
-  metadata.gz: 5c4b77eb03979138e162a7040380b9b74c31b16e1995e67e537eebd3d83074913fa39d377f29759e085f35a143a15f19407f77dcd6b2788fc5e2874b28f3591f
-  data.tar.gz: e570be50f7b9338a24489b791b0b118b0c892fcc6c8fdc7f375b6187cf63a430642d6a87c7b7016f28b9b6742e7a8c4c07cbcf94bf340a9d590dfbeb49ef0e87
+  metadata.gz: b48397862d2c8d6c8582e23445cf8c73f03f714db6bd7a73cd950f6ccc8149f8488440a827c7e31c220927e2dd7c294cc8726cd2afa1c5fb99dad2f2d8bec930
+  data.tar.gz: 5160fa06299005d522a20e8f805bd16ae5bddec4341728b92f15bbfe64c8582d756328326c29c6868636c99a9f87af74d4ee81f93e9b61f2d20a6b692f0db0cb

data/README.md

@@ -6,7 +6,7 @@
 
 Framework-agnostic matchers for Ruby. Small, explicit, and written so that the object under test cannot forge a match.
 
-![A Rubyist juggling between Matchi letters](https://github.com/fixrb/matchi/raw/main/img/matchi.png)
+![A pixel-art jester juggling the letters of Matchi](https://github.com/fixrb/matchi/raw/main/img/matchi.png)
 
 ## Installation
 
@@ -91,9 +91,9 @@ Matchi::Change.new(list, :length).from(1).to(2).match? { list << 1 } # => true
 
 `BeWithin.new(delta)` and `Change#from(value)` are builders, not matchers: they do not respond to `match?` until `of` or `to` completes them.
 
-Arguments are validated when the matcher is built (`ArgumentError`); a name is resolved when the matcher runs (`NameError`, or `TypeError` when the constant is not a module). A block is always required by `match?`. Whatever the actual value or an observed method raises propagates; `RaiseException` catches what its block raises, not what its message filter or the resolution of its name raises.
+Arguments are validated when the matcher is built (`ArgumentError`); a name is resolved when the matcher runs (`NameError`, or `TypeError` when the constant is not a module, or not an exception class for `RaiseException`). A block is always required by `match?`. Whatever the actual value or an observed method raises propagates; `RaiseException` rescues what its block raises, within the limits below, not what its message filter or the resolution of its name raises.
 
-`RaiseException` catches every `Exception`, including `SystemExit` and `Interrupt`, so that a specification can assert on them; an unexpected `exit` inside the block is a failure, not the end of the process.
+`RaiseException` rescues an exception of the expected class, and any `StandardError`, `ScriptError`, `SystemStackError` or `SystemExit` (the exceptions [Defi](https://fixrb.dev/gems/defi/) keeps too), which it then compares with the expected class. Anything else, an `Interrupt`, a signal, a `NoMemoryError`, the exception with which an enclosing `Timeout` ends its block, goes through as it would with any other matcher, unless that is the class expected: `RaiseException.new(Interrupt)` rescues an `Interrupt`. An unexpected `exit` inside the block is the wrong exception, so `false`, not the end of the process.
 
 `Change` observes a value: when the observed method returns the same unfrozen object twice (an `attr_reader` on a mutated array, say), `match?` raises instead of reporting no change. Observe `items.length`, or use `to`.
 
@@ -130,11 +130,16 @@ If you come from RSpec or Minitest, these will surprise you:
 
 - `Eq` is RSpec's `eql`, not its `eq`: it compares with `eql?`, so `1` is not `1.0`, and a value object that only defines `==` never matches. Define `eql?` and `hash` on it, or use `Satisfy`. `Integer#==` hands the comparison to the other operand, which is why Matchi does not use it.
 - `Match` takes a `Regexp` only. For a literal substring, `Matchi::Match.new(Regexp.new(Regexp.escape("a.b")))`.
-- `RaiseException` is `raise_error`; it needs an exception class, or its name, and takes an optional message.
+- `RaiseException` is `raise_error`; it needs an exception class, or its name, and takes an optional message. It does not rescue an `Interrupt`, a signal, a `NoMemoryError` or the exception with which an enclosing `Timeout` ends its block, unless that is the class expected, where `raise_error` rescues every `Exception`.
 - `Change#to` demands a change: a value already equal to the target does not pass. `Change` without a refinement needs the observed method to return a value, not the mutated object.
 - `Predicate` only calls a method of the actual value: `be_nil` calls `nil?`, but `be_truthy`, `be_falsey` and `be_a` are not predicates and do not exist. Use `Be.new(nil)`, `Satisfy`, `BeAKindOf`.
 - There is no `and`, `or`, `not_to` or `all`: compose in your framework, with plain booleans.
 
+## Changes in 6.0
+
+- `RaiseException` no longer rescues every `Exception`: it rescues the expected class, and any `StandardError`, `ScriptError`, `SystemStackError` or `SystemExit`, which it compares with the expected class. An `Interrupt`, a signal, a `NoMemoryError` or the exception with which an enclosing `Timeout` ends its block goes through unless that is the class expected, where 5.0 reported it as a failed match. `RaiseException.new(Exception)` still rescues everything, as asked.
+- The message filter of `RaiseException` and `Match` compare a plain copy of the actual `String`: a subclass could answer `valid_encoding?` for it and turn the comparison into an error.
+
 ## Changes in 5.0
 
 - `BeAKindOf`, `BeAnInstanceOf` and `RaiseException` accept a module directly, so anonymous classes work. A name is still accepted; it must be a constant path (`"Foo::bar"` is rejected at construction) and resolve to a module, or a class for `BeAnInstanceOf` and an exception class for `RaiseException`. `BeAnInstanceOf` rejects a module that is not a class.

data/lib/matchi/match.rb

@@ -31,7 +31,8 @@ module Matchi
       actual = yield
       return false unless ::String === actual || ::Symbol === actual
 
-      string = ::Symbol === actual ? actual.name : actual
+      # A plain copy: a subclass of String has no say in the comparison.
+      string = ::String.new(::Symbol === actual ? actual.name : actual)
       return false unless string.valid_encoding?
 
       begin

data/lib/matchi/raise_exception.rb

@@ -9,11 +9,13 @@ module Matchi
   # message: a String the message must be `eql?` to, or a Regexp it must
   # match.
   #
-  # Every `Exception` is caught, including `SystemExit` and `Interrupt`: a
-  # specification must be able to assert on any of them, so an unexpected
-  # `exit` or Ctrl-C inside the block is reported as a failure, not
-  # propagated. The expected class can be given directly, or by name; see
-  # {Matchi::Constant}.
+  # The matcher rescues an exception of the expected class, and any
+  # `StandardError`, `ScriptError`, `SystemStackError` or `SystemExit`,
+  # which it then compares with the expected class. Anything else, an
+  # `Interrupt`, a signal, a `NoMemoryError`, the exception with which an
+  # enclosing `Timeout` ends its block, goes through as it would with any
+  # other matcher, unless that is the class expected. The expected class can
+  # be given directly, or by name; see {Matchi::Constant}.
   #
   # @example
   #   Matchi::RaiseException.new(ZeroDivisionError).match? { 1 / 0 }              # => true
@@ -45,11 +47,15 @@ module Matchi
       # mistaken for an exception raised by the block.
       klass = expected_class
 
+      # The expected class first, whatever it is; then what a block raises
+      # on its own, the exceptions Defi keeps too.
       begin
         yield
         false
-      rescue ::Exception => e # rubocop:disable Lint/RescueException
-        klass === e && message?(e)
+      rescue klass => e
+        message?(e)
+      rescue ::StandardError, ::ScriptError, ::SystemStackError, ::SystemExit
+        false
       end
     end
 
@@ -85,13 +91,17 @@ module Matchi
     end
 
     # The message is whatever the exception answers to `message`, which is
-    # its own data, as with any exception; it must be a valid String. The
-    # expected String or Regexp receives the comparison.
+    # its own data, as with any exception; it must be a String, copied so
+    # that a subclass has no say, and valid. The expected String or Regexp
+    # receives the comparison.
     def message?(exception)
       return true if @message.nil?
 
       message = exception.message
-      return false unless ::String === message && message.valid_encoding?
+      return false unless ::String === message
+
+      message = ::String.new(message)
+      return false unless message.valid_encoding?
 
       ::String === @message ? @message.eql?(message) : @message.match?(message)
     rescue ::Encoding::CompatibilityError

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: matchi
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Cyril Kato
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: 'Matchi provides small, explicit expectation matchers for any Ruby testing
   framework. The expected value always controls the comparison, so the object under
@@ -45,10 +44,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/fixrb/matchi/issues
+  changelog_uri: https://github.com/fixrb/matchi#changes-in-60
   documentation_uri: https://rubydoc.info/gems/matchi
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/fixrb/matchi
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -63,8 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.23
 specification_version: 4
 summary: Framework-agnostic matchers for secure Ruby testing
 test_files: []