minitest-should_just_work 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c51d03bb5868a93ef411c8bea2965fda5f5c5c2f46027a0b33eaefbe47875f06
+  data.tar.gz: d2d76601465d49af062147d9865690748bb28469e0c27741027226fd8f77c71b
+SHA512:
+  metadata.gz: 6ff1d470e6cf19c68732168cc553a220bddfdb2f0710c3d3dcc7ac861dcee4ed0fc399bc76f3b7e8c76deb701c503b15c77fde2bb4008a358dddf89f7e664139
+  data.tar.gz: d3effe294c0a229ea5ddde236d1756ee7b0beb9cccdfdc794874908dfdb8606034b2a800186ec2162513a7d4b0fd373f78da270e22da86db588c4c5bded9028c

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-12-21
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in minitest-should_just_work.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "rubocop", "~> 1.21"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Priit Tark
+
+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,168 @@
+# Minitest::ShouldJustWork
+
+Classic Rspec-like .should/.should_not matching for MiniTest.
+
+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.
+
+*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.
+
+(*Ouch! Monkey patch?* Yes! But it only defines `Object#should` and 
+ `#should_not`.)
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+``` ruby
+group :test do
+  gem 'minitest-spec-rails'
+  gem 'minitest-should_just_work'
+end
+```
+
+    $ bundle
+
+## Usage
+
+``` ruby
+require 'minitest/autorun'
+require 'minitest/should_just_work'
+
+describe "Books" do
+  it "should work" do
+    book = Book.new title: "Revolution"
+
+    book.title.should == "Revolution"
+  end
+end
+
+```
+
+Then you may use it as so:
+
+```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
+  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"
+
+  otherwise "The title should've been set on constructor"
+  book.title.should == "Pride & Prejudice"
+end
+```
+
+Result:
+
+```
+1) Failure:
+should work(Test) [your_test.rb:77]:
+The title should've been set on constructor.
+Expected: "Pride & Prejudice"
+  Actual: nil
+```
+
+Or you can use `.blaming` which does the same thing (with a more cumbersome 
+    syntax):
+
+``` ruby
+it "should work" do
+  book = Book.new title: "Pride & Prejudice"
+
+  message = "The title should've been set on constructor"
+  book.title.should.blaming(message) == "Pride & Prejudice"
+end
+```
+
+## Extending
+
+Need to create your own matchers? Create your new matcher in a module, then use 
+`MiniTest::ShouldJustWork.add`.
+
+```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
+
+MiniTest::ShouldJustWork.add DanceMatcher
+
+# Then in your tests, use:
+dancer.should.boogie_all_night!
+```
+
+## Acknowledgements & licensing
+
+(c) 2022 Priit Tark, MIT license
+(c) 2013 Rico Sta. Cruz, MIT license

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/minitest/should_just_work/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Minitest
+  module ShouldJustWork
+    VERSION = "0.1.0"
+  end
+end

data/lib/minitest/should_just_work.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "should_just_work/version"
+
+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
+#
+
+module Minitest
+  module ShouldJustWork
+    class Error < StandardError; end
+
+    class Should
+      attr_reader :left, :msg
+
+      def self.init(test) # :nodoc:
+        @@test = test
+      end
+
+      # Includes a module to extend .should with more matchers.
+      def self.add(extension)
+        send :include, extension
+      end
+
+      def initialize(left)
+        @left = left
+
+        return unless test.msg
+
+        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
+
+      def negative?() @neg; end
+      def positive?() !@neg; end
+      def test()      @@test; end
+      def not()       @neg = true; self; end
+
+      def true()    true_or_false(true); end
+      def false()   true_or_false(false); end
+
+      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")
+      end
+
+      def blaming(msg);   @msg = msg; self; end
+      def messaging(msg); @msg = msg; self; end
+
+      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
+
+      def match(right)          self =~ right; end
+      def equal(right)          self == right; 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
+
+      def assert_or_refute(what, *args, &blk)
+        args << msg
+        test.send((positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, &blk)
+      end
+
+      def refute_or_assert(what, *args)
+        args << msg
+        test.send((negative? ? :"assert_#{what}" : :"refute_#{what}"), *args)
+      end
+
+      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
+
+      def raise(ex=StandardError, &blk)
+        if positive?
+          test.send :assert_raises, ex, msg, &blk
+        else
+          warn "ShouldJustWork: should.not.raise is not supported"
+        end
+      end
+
+      def method_missing(meth, *args, &blk)
+        result = left.send(:"#{meth}?", *args, &blk)
+        method = positive? ? :assert : :refute
+
+        args = [result]
+        args << msg if msg
+
+        test.send method, *args
+      end
+    end
+  end
+end
+
+class Object
+  def should
+    MiniTest::ShouldJustWork::Should.new(self)
+  end
+
+  def should_not
+    should.not
+  end
+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 before_setup(*a, &block)
+      MiniTest::ShouldJustWork::Should.init self
+      mts_before_setup(*a, &block)
+    end
+
+    def msg(string=nil)
+      self.msg = string if string
+      @msg
+    end
+
+    def msg=(string)
+      @msg = string
+    end
+
+    def otherwise(message)
+      msg message
+    end
+  end
+end

data/sig/minitest/should_just_work.rbs

@@ -0,0 +1,6 @@
+module Minitest
+  module ShouldJustWork
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: minitest-should_just_work
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rico Sta. Cruz
+- Priit Tark
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    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:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  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:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Enables classic .should/.should_not syntax similar to classic RSpec on
+  your MiniTest tests.
+email:
+- priit@domify.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- 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
+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:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: RSpec-like .should/.should_not syntax for MiniTest.
+test_files: []