minitest-should_just_work 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c51d03bb5868a93ef411c8bea2965fda5f5c5c2f46027a0b33eaefbe47875f06
-  data.tar.gz: d2d76601465d49af062147d9865690748bb28469e0c27741027226fd8f77c71b
+  metadata.gz: 569475f4cf322d65bba65f7af827108621daf18e40ae175385b73b402766e616
+  data.tar.gz: bb2d04f22ec617d48f86d09166363281282bdadb8d3af51a69847d201b7bc517
 SHA512:
-  metadata.gz: 6ff1d470e6cf19c68732168cc553a220bddfdb2f0710c3d3dcc7ac861dcee4ed0fc399bc76f3b7e8c76deb701c503b15c77fde2bb4008a358dddf89f7e664139
-  data.tar.gz: d3effe294c0a229ea5ddde236d1756ee7b0beb9cccdfdc794874908dfdb8606034b2a800186ec2162513a7d4b0fd373f78da270e22da86db588c4c5bded9028c
+  metadata.gz: 42590821b85e5a88ceca0f43d982af5e508e836fb8385c9e639f1ec0b5a3075f556a9b63d2d5d8a56a338a9eb2549bc3ab1350f47d5eff755fdb60db9ed9d180
+  data.tar.gz: f3d9eb37e609b564c718391283c98dd858a0b3e0c6c9f33dc95f46329a1931737d1b6c80200f117f5bc365e3c189c4fb27df69e4add379f60e4aa65d0c645158

data/.rubocop.yml

@@ -1,5 +1,7 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
 
 Style/StringLiterals:
   Enabled: true
@@ -11,3 +13,34 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+# The Object patch belongs next to the DSL it exists for, not hidden in a file
+# of its own.
+Style/OneClassPerFile:
+  Exclude:
+    - lib/minitest/should_just_work.rb
+    - test/**/*
+
+# `obj.should == 2` is a statement by design, and `obj.should == nil` is the
+# documented way to assert nil. These three cops object to exactly that, so any
+# test suite using this gem has to switch them off.
+Lint/Void:
+  Exclude:
+    - test/**/*
+Style/NilComparison:
+  Exclude:
+    - test/**/*
+Style/NonNilCheck:
+  Exclude:
+    - test/**/*
+
+# A `describe` block covering the whole DSL is far longer than the default limit.
+Metrics/BlockLength:
+  Exclude:
+    - test/**/*
+Metrics/MethodLength:
+  Exclude:
+    - test/**/*
+Metrics/AbcSize:
+  Exclude:
+    - test/**/*

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 ## [Unreleased]
 
+## [1.0.0] - 2026-08-25
+
+This release narrows the gem to the operator syntax it was really used for, and
+fixes everything that was broken in the part that stays.
+
+### Removed
+
+- The chained matcher DSL. `should.be`, `.a`, `.an`, `.nil`, `.empty`,
+  `.include`, `.same`, `.instance_of`, `.kind_of`, `.respond_to`, `.close`,
+  `.in_epsilon`, `.satisfy`, `.true`, `.false`, `.match` and `.equal` are gone,
+  along with the pass-through predicates (`should.be.empty?`) and the custom
+  matcher hook (`ShouldJustWork.add` / `Should.add`).
+
+  Use plain Minitest assertions for those: `assert_empty x`, `assert_includes x, y`,
+  `assert_instance_of Y, x`, and so on. The old spellings raise `NoMethodError`
+  with a message naming what is supported, rather than silently passing.
+
+  This removes all of the metaprogramming the gem used to need: the matcher
+  proxy no longer defines `method_missing` matchers and no longer undefines the
+  methods it inherits from `Object`.
+
+### Fixed
+
+- Works on Minitest 6. The gem required the removed `minitest/unit`, and patched
+  the removed `MiniTest` constant alias, so on Minitest 6 it failed to load at
+  all. It now requires `minitest` and uses the `Minitest` namespace, and is
+  tested against both Minitest 5 and 6.
+- `x.should == nil` now asserts nil. It used to become `assert_equal nil, x`,
+  which Minitest 5 deprecates and Minitest 6 fails outright.
+- `should.raise(SomeError) { ... }` passed a `nil` message through to
+  `assert_raises`, which Minitest 6 rejects with a `TypeError`.
+- The test currently running is kept in a thread variable instead of a class
+  variable, so assertions no longer leak between tests running in parallel
+  threads.
+- Using `should` outside of a running test now raises a clear
+  `Minitest::ShouldJustWork::Error` instead of failing obscurely.
+
+### Added
+
+- `should_not.raise(SomeError) { ... }` and `should_not.throw(:sym) { ... }`,
+  which previously printed a warning and asserted nothing.
+- A real test suite, and CI across Ruby 3.1-4.0 and Minitest 5 and 6.
+
+### Changed
+
+- Requires Ruby >= 3.1 (was 2.6, which has been end-of-life since 2022).
+- The `minitest` dependency is constrained to `>= 5.0, < 7`.
+
 ## [0.1.0] - 2022-12-21
 
 - Initial release

data/Gemfile

@@ -5,8 +5,9 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in minitest-should_just_work.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
-
-gem "minitest", "~> 5.0"
+# CI pins this to test against every supported Minitest line.
+minitest_version = ENV.fetch("MINITEST_VERSION", nil)
+gem "minitest", minitest_version if minitest_version
 
+gem "rake", "~> 13.0"
 gem "rubocop", "~> 1.21"

data/README.md

@@ -1,20 +1,24 @@
 # Minitest::ShouldJustWork
 
-Classic Rspec-like .should/.should_not matching for MiniTest.
+[![CI](https://github.com/priit/minitest-should_just_work/actions/workflows/ci.yml/badge.svg)](https://github.com/priit/minitest-should_just_work/actions/workflows/ci.yml)
 
-This gem is heavely inspired from the minitest-should_syntax gem,
-what has not updated a long time. Therefore we need this new gem to support .should syntax.
+Classic RSpec-like `.should` / `.should_not` comparisons for Minitest.
 
-*minitest-should_just_work* lets you use a syntax similar to classic RSpec on your MiniTest 
-tests.  It monkey-patches Object to translate RSpec-like sugar into plain 
-MiniTest `assert` matchers.
+```ruby
+book.title.should == "Revolution"
+```
 
-(*Ouch! Monkey patch?* Yes! But it only defines `Object#should` and 
+That is the whole idea. The gem monkey-patches Object so that comparison
+operators after `.should` turn into plain Minitest assertions.
+
+(*Ouch! Monkey patch?* Yes! But it only defines `Object#should` and
  `#should_not`.)
 
+Requires Ruby >= 3.1. Tested against Minitest 5 and Minitest 6.
+
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
+Add it to your application's Gemfile:
 
 ``` ruby
 group :test do
@@ -38,131 +42,88 @@ describe "Books" do
     book.title.should == "Revolution"
   end
 end
+```
+
+### Comparisons
+
+| Minitest::ShouldJustWork          | [Minitest::Assertions]           |
+|-----------------------------------|----------------------------------|
+| `x.should == y`                   | `assert_equal y, x`              |
+| `x.should == nil`                 | `assert_nil x`                   |
+| `x.should != y`                   | `refute_equal y, x`              |
+| `x.should != nil`                 | `refute_nil x`                   |
+| `x.should =~ /y/`                 | `assert_match /y/, x`            |
+| `x.should > y`                    | `assert_operator x, :>, y`       |
+| `x.should < y`                    | `assert_operator x, :<, y`       |
+| `x.should >= y`                   | `assert_operator x, :>=, y`      |
+| `x.should <= y`                   | `assert_operator x, :<=, y`      |
 
+Note that `x.should == nil` asserts nil rather than equality with nil. Minitest 5
+deprecates `assert_equal nil, x` and Minitest 6 fails it outright, so this is the
+only spelling that can work.
+
+### Negating
+
+Use `should_not`, or `should.not`, to turn any comparison into its `refute_`:
+
+```ruby
+  obj.should_not == 3                # => refute_equal 3, obj
+  obj.should_not =~ /regex/          # => refute_match /regex/, obj
+  obj.should_not == nil              # => refute_nil obj
 ```
 
-Then you may use it as so:
+### Exceptions and throws
 
 ```ruby
-  obj.should == 2                    # => assert_equal 2, obj
-  obj.should =~ /regex/              # => assert_match /regex/, obj
-  obj.should != 3                    # => assert_not_equal 3, obj
-  obj.should.nil                     # => assert_nil obj
-  obj.should.respond_to(:freeze)     # => assert_respond_to obj, :freeze 
-
-# Note that .be, .a and .an are optional.
-  obj.should.nil                     # => assert_nil obj
-  obj.should.be.nil                  # => assert_nil obj
-  obj.should.be.a.nil                # => assert_nil obj
-
-# Use `should.not` instead `should` to negate any comparison.
-  obj.should.not == 3                # => refute_equal 3, obj
-  obj.should.not =~ /regex/          # => refute_match obj, regex
-  obj.should.not.be.nil              # => refute obj.nil?
-
-# Anything else will pass through with a ?:
-  obj.should.be.good_looking         # => assert obj.good_looking?
-
-# Testing exceptions:
   should.raise ZeroDivisionError do
-    2/0
+    2 / 0
   end
-```
-
-## Wrapped assertions
-
-These are based on [MiniTest::Assertions].
-
-| MiniTest::ShouldJustWork                | [MiniTest::Assertions]      |
-|-----------------------------------------|-----------------------------|
-| x.should.equal y                        | assert_equal x, y           |
-| x.should == y                           | assert_equal x, y           |
-| x.should.not.equal                      | refute_equal x, y           |
-| x.should !=                             | refute_equal x, y           |
-| x.should.be                             | assert_same x, y            |
-| x.should.not.be                         | refute_same x, y            |
-| x.should >= *(and others)*              | assert_operator x, :>=, y   |
-| x.should.not >= *(and others)*          | refute_operator x, :>=, y   |
-| x.should.be.nil                         | assert_nil x                |
-| x.should.not.be.nil                     | refute_nil x                |
-| x.should.be.close y                     | assert_in_delta y           |
-| x.should.be.in_epsilon y                | assert_in_epsilon y         |
-| x.should.match /y/                      | assert_match x, /y/         |
-| x.should =~ /y/                         | assert_match x, /y/         |
-| x.should.not.match, should.not =~       | refute_match                |
-| x.should.be.an.instance_of y            | assert_instance_of x, y     |
-| x.should.be.a.kind_of x, y              | assert_kind_of x, y         |
-| x.should.respond_to :y                  | assert_respond_to x, :y     |
-| should.raise(x) { ... }                 | assert_raise(x) { ... }     |
-| should.throw(x) { ... }                 | assert_throws(x) { ... }    |
-| should.satisfy { ... }                  | assert_block { ... }        |
-
-[MiniTest::Assertions]: https://github.com/seattlerb/minitest/blob/master/lib/minitest/unit.rb
-
-## Messages
-
-Use the `otherwise` helper:
 
-``` ruby
-it "should work" do
-  book = Book.new title: "Pride & Prejudice"
+  should_not.raise ZeroDivisionError do
+    2 / 1
+  end
 
-  otherwise "The title should've been set on constructor"
-  book.title.should == "Pride & Prejudice"
-end
+  should.throw(:done) { throw :done }
+  should_not.throw(:done) { keep_going }
 ```
 
-Result:
+`should.raise` with no argument catches `StandardError`.
 
-```
-1) Failure:
-should work(Test) [your_test.rb:77]:
-The title should've been set on constructor.
-Expected: "Pride & Prejudice"
-  Actual: nil
-```
+[Minitest::Assertions]: https://github.com/minitest/minitest/blob/master/lib/minitest/assertions.rb
 
-Or you can use `.blaming` which does the same thing (with a more cumbersome 
-    syntax):
+## RuboCop
 
-``` ruby
-it "should work" do
-  book = Book.new title: "Pride & Prejudice"
+`obj.should == 2` is a statement whose value is discarded, and `obj.should == nil`
+compares against nil on purpose. Three cops object to exactly that, so switch
+them off for your tests:
 
-  message = "The title should've been set on constructor"
-  book.title.should.blaming(message) == "Pride & Prejudice"
-end
+``` yaml
+Lint/Void:
+  Exclude:
+    - test/**/*
+Style/NilComparison:
+  Exclude:
+    - test/**/*
+Style/NonNilCheck:
+  Exclude:
+    - test/**/*
 ```
 
-## Extending
+Ruby's own `-w` will also report "useless use of == in void context" for every
+line, so leave warnings off for your test task.
 
-Need to create your own matchers? Create your new matcher in a module, then use 
-`MiniTest::ShouldJustWork.add`.
+## Development
 
-```ruby
-module DanceMatcher
-  def boogie_all_night!
-    # Delegates to `assert(condition, message)`.
-    #
-    #   positive?   - returns `true` if .should, or `false` if .should.not
-    #   test        - the MiniTest object
-    #   msg         - the failure message. `nil` if not set
-    #
-    if positive?
-      test.assert left.respond_to?(:dance), msg
-    else
-      test.refute left.respond_to?(:dance), msg
-    end
-  end
-end
+    $ bin/setup
+    $ bundle exec rake        # tests and RuboCop
 
-MiniTest::ShouldJustWork.add DanceMatcher
+To run the suite against a particular Minitest line:
 
-# Then in your tests, use:
-dancer.should.boogie_all_night!
-```
+    $ MINITEST_VERSION="~> 5.0" bundle install && MINITEST_VERSION="~> 5.0" bundle exec rake test
 
 ## Acknowledgements & licensing
 
-(c) 2022 Priit Tark, MIT license
+Inspired by the minitest-should_syntax gem.
+
+(c) 2022-2026 Priit Tark, MIT license
 (c) 2013 Rico Sta. Cruz, MIT license

data/Rakefile

@@ -7,6 +7,9 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/test_*.rb"]
+  # The whole point of this gem is that `obj.should == 2` is a statement, which
+  # Ruby's -w flags as a useless use of == in void context on every single line.
+  t.warning = false
 end
 
 require "rubocop/rake_task"

data/lib/minitest/should_just_work/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module ShouldJustWork
-    VERSION = "0.1.0"
+    VERSION = "1.0.0"
   end
 end

data/lib/minitest/should_just_work.rb

@@ -1,178 +1,180 @@
 # frozen_string_literal: true
 
-require_relative "should_just_work/version"
+require "minitest"
 
-require 'minitest/unit'
-
-# Rspec-like matching for MiniTest.
-#
-# == Usage
-#
-#   # All objects get .should:
-#     obj.should == 2
-#     obj.should ~= /regex/
-#     obj.should != 3
-#     obj.should.be.true    # Truthy
-#     obj.should.be.false   # Falsy
-#
-#   # Anything else will just pass thru:
-#     obj.should.nil?     # same as: assert obj.nil?
-#     obj.should.be.nil?  # same as: assert obj.nil?
-#     obj.should.respond_to?(:freeze)
-#
-#   # You can also use should_not:
-#     obj.should_not == 3
-#     obj.should_not.be.nil?
-#
-#   # Errors and throws
-#     should.raise(Error) { lol }
-#     should.throw(:x) { lol }
-#
-#   # Messages
-#     msg "Age must be set properly"
-#     age.should == 18
-#
+require_relative "should_just_work/version"
 
+# Minitest's own namespace, reopened to hold the DSL and to teach Minitest::Test
+# about it.
 module Minitest
+  # Rspec-like operator assertions for Minitest.
+  #
+  # == Usage
+  #
+  #   obj.should == 2
+  #   obj.should != 3
+  #   obj.should == nil      # asserts nil, not equality with nil
+  #   obj.should =~ /regex/
+  #   obj.should > 1
+  #
+  #   # Negate with should_not, or with .not:
+  #   obj.should_not == 3
+  #   obj.should.not == 3
+  #
+  #   # Errors and throws:
+  #   should.raise(ArgumentError) { boom }
+  #   should_not.throw(:x) { quiet }
+  #
+  #   # Messages:
+  #   otherwise "Age must be set properly"
+  #   age.should == 18
+  #
   module ShouldJustWork
+    # Raised when the DSL is used outside of a running Minitest test.
     class Error < StandardError; end
 
+    # The object returned by Object#should. It remembers what .should was called
+    # on and forwards the comparison to the test that is currently running.
     class Should
-      attr_reader :left, :msg
+      # The chained matcher DSL (`should.be.empty`, `should.be.nil?`) was dropped
+      # in 1.0. Object answers to some of those names itself, so without this the
+      # old spelling would quietly return a boolean and pass without asserting
+      # anything. Undefined, they raise instead.
+      %i[nil? frozen? respond_to? is_a? kind_of? instance_of? eql? equal?].each do |name|
+        undef_method name if method_defined?(name)
+      end
 
+      # Remembers the test that is currently running. Minitest can run tests in
+      # parallel threads, so the test is kept in a thread variable rather than in
+      # a class variable shared by every thread.
       def self.init(test) # :nodoc:
-        @@test = test
+        ::Thread.current.thread_variable_set(:minitest_should_just_work_test, test)
       end
 
-      # Includes a module to extend .should with more matchers.
-      def self.add(extension)
-        send :include, extension
+      def self.current # :nodoc:
+        ::Thread.current.thread_variable_get(:minitest_should_just_work_test)
       end
 
       def initialize(left)
         @left = left
+        @neg = false
 
-        return unless test.msg
+        pending = test.msg
+        return unless pending
 
-        blaming test.msg
         test.msg = nil
       end
 
-      def be(right=nil) self.same(right)  if right; self; end
-      def a()  self; end
-      def an() self; end
+      # `should == nil` means assert_nil rather than assert_equal, which Minitest
+      # 6 refuses outright and Minitest 5 deprecates.
+      def ==(other)
+        other.nil? ? assert_or_refute(:nil, left) : assert_or_refute(:equal, other, left)
+      end
 
-      def negative?() @neg; end
-      def positive?() !@neg; end
-      def test()      @@test; end
-      def not()       @neg = true; self; end
+      def !=(other)
+        other.nil? ? refute_or_assert(:nil, left) : refute_or_assert(:equal, other, left)
+      end
 
-      def true()    true_or_false(true); end
-      def false()   true_or_false(false); end
+      def =~(other) = assert_or_refute(:match, other, left)
+      def >(other) = assert_or_refute(:operator, left, :>, other)
+      def <(other) = assert_or_refute(:operator, left, :<, other)
+      def >=(other) = assert_or_refute(:operator, left, :>=, other)
+      def <=(other) = assert_or_refute(:operator, left, :<=, other)
 
-      def true_or_false(bool)
-        val = !! left
-        val = !val  if bool == false
-        method = (positive? ? :"assert" : :"refute")
-        test.send method, val, [msg, 'Expected to be falsy'].compact.join("\n")
+      # Negates the comparison that follows. `should_not` is the shorthand.
+      def not
+        @neg = true
+        self
       end
 
-      def blaming(msg);   @msg = msg; self; end
-      def messaging(msg); @msg = msg; self; end
+      # should.throw(:sym) { ... } and should_not.throw(:sym) { ... }
+      def throw(sym = nil, &blk)
+        return test.send(:assert_throws, sym, msg, &blk) if positive?
 
-      def ==(right)             assert_or_refute :equal, right, left; end
-      def =~(right)             assert_or_refute :match, right, left; end
-      def !=(right)             refute_or_assert :equal, right, left; end
-      def >(right)              assert_or_refute :operator, left, :>,  right; end
-      def <(right)              assert_or_refute :operator, left, :<,  right; end
-      def >=(right)             assert_or_refute :operator, left, :>=, right; end
-      def <=(right)             assert_or_refute :operator, left, :<=, right; end
-      def include(right)        assert_or_refute :includes, left, right; end
-      def instance_of(right)    assert_or_refute :instance_of, right, left; end
-      def kind_of(right)        assert_or_refute :kind_of, right, left; end
-      def nil()                 assert_or_refute :nil, left; end
-      def same(right)           assert_or_refute :same, right, left; end
-      def respond_to(right)     assert_or_refute :respond_to, left, right; end
-      def empty()               assert_or_refute :empty, left; end
-      def satisfy(&blk)         assert_or_refute :block, &blk; end
+        ::Kernel.raise(Error, "should_not.throw needs a symbol to watch for") if sym.nil?
 
-      def match(right)          self =~ right; end
-      def equal(right)          self == right; end
+        thrown = true
+        ::Kernel.catch(sym) do
+          blk.call
+          thrown = false
+        end
+        test.send(:refute, thrown, [msg, "Expected the block not to throw #{sym.inspect}"].compact.join("\n"))
+      end
 
-      def close(right, d=0.001)       assert_or_refute :in_delta, right, left, d; end
-      def in_epsilon(right, d=0.001)  assert_or_refute :in_epsilon, right, left, d; end
+      # should.raise(SomeError) { ... } and should_not.raise(SomeError) { ... }
+      def raise(exception = ::StandardError, &)
+        return test.send(:assert_raises, *[exception, msg].compact, &) if positive?
 
-      def assert_or_refute(what, *args, &blk)
-        args << msg
-        test.send((positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, &blk)
+        raised = capture(exception, &)
+        test.send(:refute, raised,
+                  [msg, "Expected the block not to raise #{exception}, got #{raised.inspect}"].compact.join("\n"))
       end
 
-      def refute_or_assert(what, *args)
-        args << msg
-        test.send((negative? ? :"assert_#{what}" : :"refute_#{what}"), *args)
-      end
+      private
 
-      def throw(what=nil, &blk)
-        if positive?
-          test.send :assert_throws, what, msg, &blk
-        else
-          warn "ShouldJustWork: should.not.throw is not supported"
-        end
-      end
+      attr_reader :left, :msg
 
-      def raise(ex=StandardError, &blk)
-        if positive?
-          test.send :assert_raises, ex, msg, &blk
-        else
-          warn "ShouldJustWork: should.not.raise is not supported"
-        end
+      def test
+        Should.current ||
+          ::Kernel.raise(Error, "#should can only be used inside a running Minitest test")
       end
 
-      def method_missing(meth, *args, &blk)
-        result = left.send(:"#{meth}?", *args, &blk)
-        method = positive? ? :assert : :refute
+      def positive? = !@neg
+      def negative? = @neg
 
-        args = [result]
+      def assert_or_refute(what, *args)
         args << msg if msg
-
-        test.send method, *args
+        test.send(positive? ? :"assert_#{what}" : :"refute_#{what}", *args)
       end
-    end
-  end
-end
 
-class Object
-  def should
-    MiniTest::ShouldJustWork::Should.new(self)
-  end
+      def refute_or_assert(what, *args)
+        args << msg if msg
+        test.send(negative? ? :"assert_#{what}" : :"refute_#{what}", *args)
+      end
 
-  def should_not
-    should.not
-  end
-end
+      def capture(exception)
+        yield
+        nil
+      rescue exception => e
+        e
+      end
 
-# Patch MiniTest::Test:before_setup to invoke ShouldJustWork,
-# and inject the #msg and #otherwise helper.
-module MiniTest
-  class Test
-    alias mts_before_setup before_setup
+      def method_missing(name, ...)
+        ::Kernel.raise(NoMethodError,
+                       "undefined matcher '#{name}'. minitest-should_just_work supports the operators " \
+                       "==, !=, =~, <, >, <= and >=, plus should.raise and should.throw")
+      end
 
-    def before_setup(*a, &block)
-      MiniTest::ShouldJustWork::Should.init self
-      mts_before_setup(*a, &block)
+      def respond_to_missing?(_name, _include_private = false) = false
     end
 
-    def msg(string=nil)
-      self.msg = string if string
-      @msg
-    end
+    # Prepended to Minitest::Test so every test hands itself to ShouldJustWork
+    # before it runs, and so tests gain the #msg and #otherwise helpers.
+    module TestHelpers
+      def before_setup
+        Should.init self
+        super
+      end
 
-    def msg=(string)
-      @msg = string
-    end
+      # Reads the failure message waiting to be attached to the next comparison,
+      # or sets it when given one.
+      def msg(string = nil)
+        self.msg = string if string
+        @msg
+      end
+
+      attr_writer :msg
 
-    def otherwise(message)
-      msg message
+      # Reads better than #msg in front of an assertion.
+      def otherwise(message) = msg(message)
     end
   end
+
+  Test.prepend ShouldJustWork::TestHelpers
+end
+
+# The one monkey patch this gem makes: every object gains #should and #should_not.
+class Object
+  def should = Minitest::ShouldJustWork::Should.new(self)
+  def should_not = should.not
 end

data/sig/minitest/should_just_work.rbs

@@ -1,6 +1,50 @@
 module Minitest
   module ShouldJustWork
     VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+    class Error < StandardError
+    end
+
+    class Should
+      def self.init: (untyped test) -> void
+      def self.current: () -> untyped
+
+      def initialize: (untyped left) -> void
+
+      def ==: (untyped other) -> untyped
+      def !=: (untyped other) -> untyped
+      def =~: (untyped other) -> untyped
+      def >: (untyped other) -> untyped
+      def <: (untyped other) -> untyped
+      def >=: (untyped other) -> untyped
+      def <=: (untyped other) -> untyped
+
+      def throw: (?Symbol sym) { () -> untyped } -> untyped
+      def raise: (?Class exception) { () -> untyped } -> untyped
+
+      private
+
+      attr_reader left: untyped
+      attr_reader msg: String?
+
+      def test: () -> untyped
+      def positive?: () -> bool
+      def negative?: () -> bool
+      def assert_or_refute: (Symbol what, *untyped args) -> untyped
+      def refute_or_assert: (Symbol what, *untyped args) -> untyped
+      def capture: (Class exception) { () -> untyped } -> Exception?
+    end
+
+    module TestHelpers
+      def before_setup: () -> void
+      def msg: (?String? string) -> String?
+      def msg=: (String? string) -> String?
+      def otherwise: (String message) -> String?
+    end
   end
 end
+
+class Object
+  def should: () -> Minitest::ShouldJustWork::Should
+  def should_not: () -> Minitest::ShouldJustWork::Should
+end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-should_just_work
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Rico Sta. Cruz
 - Priit Tark
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -17,44 +16,22 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '5.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '7'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '5.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7'
 description: Enables classic .should/.should_not syntax similar to classic RSpec on
-  your MiniTest tests.
+  your Minitest tests.
 email:
 - priit@domify.io
 executables: []
@@ -70,14 +47,15 @@ files:
 - lib/minitest/should_just_work.rb
 - lib/minitest/should_just_work/version.rb
 - sig/minitest/should_just_work.rbs
-homepage: http://github.com/priit/minitest-should_just_work
+homepage: https://github.com/priit/minitest-should_just_work
 licenses:
 - MIT
 metadata:
-  homepage_uri: http://github.com/priit/minitest-should_just_work
-  source_code_uri: http://github.com/priit/minitest-should_just_work
-  changelog_uri: http://github.com/priit/minitest-should_just_work/CHANGELOG.md
-post_install_message:
+  homepage_uri: https://github.com/priit/minitest-should_just_work
+  source_code_uri: https://github.com/priit/minitest-should_just_work
+  bug_tracker_uri: https://github.com/priit/minitest-should_just_work/issues
+  changelog_uri: https://github.com/priit/minitest-should_just_work/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -85,15 +63,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
-summary: RSpec-like .should/.should_not syntax for MiniTest.
+summary: RSpec-like .should/.should_not syntax for Minitest.
 test_files: []