matchi 1.0.7 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d213c300548625425d0a0e93897dee638fc782392cf1364c3e98847a73af8df
-  data.tar.gz: a5d1766ef4051bdcbcc9c35f93f62d4e3992531112fdd1dfad5f6956e9e5c01b
+  metadata.gz: c15a21ea2bcdc3ea9c43344bb1ff12216a384bc3d19a996c39a1138c28d18150
+  data.tar.gz: d023d2472ced57399fd14aea2a35cd36b75f7a9ac3705efd48985ccc03a6b9df
 SHA512:
-  metadata.gz: bb87e6c3d74fdcd4fc0983981c6b26bd7166e32ddf7bb69ebcbda2d9cf18e71af798f5bccb3ab5a6a45ef31db919c1c8d42d0ea26a051fee35673df833578e0b
-  data.tar.gz: d309507d97b8561bdeaea13c2f3d4a78d40fcafd1fdd03ec125dda24de10ef9c28935d66266905ab4cdfbb63a937e791f16079406ba96a03d9a7c6260d09bdf7
+  metadata.gz: be27946a8a1aa3d24b978603be5efc2ce29eea9a18455dba435276329388fd1448c8e0f770b649ca34ad0cfce711a4b34939d665254741406f4bfa7602342475
+  data.tar.gz: dcdf2ece3a08c3dd266a9f01ebcb76013f3ab6e699b2bb8205656f7e3cd3ba76f786921c68516efc940404e72862a0bd5df9a021bb8c0c0b80720048e2738cc8

data/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2019 Cyril Kato
+Copyright (c) 2015-2021 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,39 +1,31 @@
 # Matchi
 
-[![Build Status](https://api.travis-ci.org/fixrb/matchi.svg?branch=master)][travis]
+[![Build Status](https://api.travis-ci.org/fixrb/matchi.svg?branch=main)][travis]
 [![Code Climate](https://codeclimate.com/github/fixrb/matchi/badges/gpa.svg)][codeclimate]
 [![Gem Version](https://badge.fury.io/rb/matchi.svg)][gem]
-[![Inline docs](https://inch-ci.org/github/fixrb/matchi.svg?branch=master)][inchpages]
 [![Documentation](https://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
 
-> Collection of expectation matchers for Ruby.
-
-## Contact
-
-* Home page: https://github.com/fixrb/matchi
-* Bugs/issues: https://github.com/fixrb/matchi/issues
-
-## Rubies
-
-* [MRI](https://www.ruby-lang.org/)
-* [Rubinius](https://rubinius.com/)
-* [JRuby](https://www.jruby.org/)
+> Collection of expectation matchers for Ruby 🤹
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'matchi'
+gem "matchi"
 ```
 
 And then execute:
 
-    $ bundle
+```sh
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install matchi
+```sh
+gem install matchi
+```
 
 ## Usage
 
@@ -42,52 +34,59 @@ Or install it yourself as:
 **Equivalence** matcher:
 
 ```ruby
-eql = Matchi::Matchers::Eql::Matcher.new('foo')
-eql.matches? { 'foo' } # => true
+eql = Matchi::Matcher::Eql.new("foo")
+eql.matches? { "foo" } # => true
 ```
 
 **Identity** matcher:
 
 ```ruby
-equal = Matchi::Matchers::Equal::Matcher.new(:foo)
+equal = Matchi::Matcher::Equal.new(:foo)
 equal.matches? { :foo } # => true
 ```
 
 **Regular expressions** matcher:
 
 ```ruby
-match = Matchi::Matchers::Match::Matcher.new(/^foo$/)
-match.matches? { 'foo' } # => true
+match = Matchi::Matcher::Match.new(/^foo$/)
+match.matches? { "foo" } # => true
 ```
 
 **Expecting errors** matcher:
 
 ```ruby
-raise_exception = Matchi::Matchers::RaiseException::Matcher.new(NameError)
+raise_exception = Matchi::Matcher::RaiseException.new(NameError)
 raise_exception.matches? { Boom } # => true
 ```
 
 **Truth** matcher:
 
 ```ruby
-be_true = Matchi::Matchers::BeTrue::Matcher.new
+be_true = Matchi::Matcher::BeTrue.new
 be_true.matches? { true } # => true
 ```
 
 **Untruth** matcher:
 
 ```ruby
-be_false = Matchi::Matchers::BeFalse::Matcher.new
+be_false = Matchi::Matcher::BeFalse.new
 be_false.matches? { false } # => true
 ```
 
 **Nil** matcher:
 
 ```ruby
-be_nil = Matchi::Matchers::BeNil::Matcher.new
+be_nil = Matchi::Matcher::BeNil.new
 be_nil.matches? { nil } # => true
 ```
 
+**Type/class** matcher:
+
+```ruby
+be_an_instance_of = Matchi::Matcher::BeAnInstanceOf.new(String)
+be_an_instance_of.matches? { "foo" } # => true
+```
+
 ### Custom matchers
 
 Custom matchers can easily be defined for expressing expectations.  They can be any Ruby class that responds to `matches?`, `to_s` and `to_h` instance methods.
@@ -96,55 +95,35 @@ A **Be the answer** matcher:
 
 ```ruby
 module Matchi
-  module Matchers
-    module BeTheAnswer
-      class Matcher
-        def matches?
-          42.equal? yield
-        end
-
-        def to_s
-          'be_the_answer'
-        end
-
-        def to_h
-          { BeTheAnswer: [] }
-        end
+  module Matcher
+    class BeTheAnswer < ::Matchi::Matcher::Base
+      def matches?
+        42.equal?(yield)
       end
     end
   end
 end
 
-be_the_answer = Matchi::Matchers::BeTheAnswer::Matcher.new
+be_the_answer = Matchi::Matcher::BeTheAnswer.new
 be_the_answer.matches? { 42 } # => true
 ```
 
 A **Be prime** matcher:
 
 ```ruby
-require 'prime'
+require "prime"
 
 module Matchi
-  module Matchers
-    module BePrime
-      class Matcher
-        def matches?
-          Prime.prime? yield
-        end
-
-        def to_s
-          'be_prime'
-        end
-
-        def to_h
-          { BePrime: [] }
-        end
+  module Matcher
+    class BePrime < ::Matchi::Matcher::Base
+      def matches?
+        Prime.prime?(yield)
       end
     end
   end
 end
 
-be_prime = Matchi::Matchers::BePrime::Matcher.new
+be_prime = Matchi::Matcher::BePrime.new
 be_prime.matches? { 42 } # => false
 ```
 
@@ -152,70 +131,47 @@ A **Start with** matcher:
 
 ```ruby
 module Matchi
-  module Matchers
-    module StartWith
-      class Matcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def matches?
-          !Regexp.new("^#{@expected}").match(yield).nil?
-        end
-
-        def to_s
-          'start_with'
-        end
-
-        def to_h
-          { StartWith: [@expected] }
-        end
+  module Matcher
+    class StartWith < ::Matchi::Matcher::Base
+      def initialize(expected)
+        super()
+        @expected = expected
+      end
+
+      def matches?
+        Regexp.new(/\A#{expected}/).match?(yield)
       end
     end
   end
 end
 
-start_with = Matchi::Matchers::StartWith::Matcher.new('foo')
-start_with.matches? { 'foobar' } # => true
+start_with = Matchi::Matcher::StartWith.new("foo")
+start_with.matches? { "foobar" } # => true
 ```
 
-## Security
-
-As a basic form of security __Matchi__ provides a set of SHA512 checksums for
-every Gem release.  These checksums can be found in the `checksum/` directory.
-Although these checksums do not prevent malicious users from tampering with a
-built Gem they can be used for basic integrity verification purposes.
-
-The checksum of a file can be checked using the `sha512sum` command.  For
-example:
+## Contact
 
-    $ sha512sum pkg/matchi-0.0.1.gem
-    548d9f669ded4e622182791a5390aaceae0bf2e557b0864f05a842b0be2c65e10e1fb8499f49a3b9efd0e8eaeb691351b1c670d6316ce49965a99683b1071389  pkg/matchi-0.0.1.gem
+* Home page: https://github.com/fixrb/matchi
+* Bugs/issues: https://github.com/fixrb/matchi/issues
 
 ## Versioning
 
 __Matchi__ follows [Semantic Versioning 2.0](https://semver.org/).
 
-## Contributing
+## License
 
-1. [Fork it](https://github.com/fixrb/matchi/fork)
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+The [gem](https://rubygems.org/gems/matchi) is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## License
+***
 
-See `LICENSE.md` file.
+<p>
+  This project is sponsored by:<br />
+  <a href="https://sashite.com/"><img
+    src="https://github.com/fixrb/matchi/raw/main/img/sashite.png"
+    alt="Sashite" /></a>
+</p>
 
 [gem]: https://rubygems.org/gems/matchi
 [travis]: https://travis-ci.org/fixrb/matchi
 [codeclimate]: https://codeclimate.com/github/fixrb/matchi
-[inchpages]: https://inch-ci.org/github/fixrb/matchi
 [rubydoc]: https://rubydoc.info/gems/matchi/frames
-
-***
-
-This project is sponsored by:
-
-[![Sashite](https://pbs.twimg.com/profile_images/618485028322975744/PZ9qPuI__400x400.png)](https://sashite.com/)

data/lib/matchi.rb

@@ -4,4 +4,4 @@
 module Matchi
 end
 
-require_relative File.join('matchi', 'matchers')
+require_relative File.join("matchi", "matcher")

data/lib/matchi/helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "matcher"
+
+module Matchi
+  # Collection of helper methods.
+  module Helper
+    ::Matchi::Matcher.constants.each do |matcher_const|
+      next if matcher_const.equal?(:Base)
+
+      matcher_klass = ::Matchi::Matcher.const_get(matcher_const)
+
+      # Define a method for the given matcher.
+      #
+      # @example Given the `Matchi::Matchers::Equal::Matcher` matcher, its
+      #   method would be:
+      #
+      #   def equal(expected)
+      #     Matchi::Matchers::Equal::Matcher.new(expected)
+      #   end
+      #
+      # @return [#matches?] The matcher.
+      define_method(matcher_klass.to_sym) do |*args|
+        matcher_klass.new(*args)
+      end
+    end
+  end
+end

data/lib/matchi/matcher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Matchi
+  # Collection of matcher classes.
+  module Matcher
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "matcher", "*.rb")].each do |fname|
+  require_relative fname
+end

data/lib/matchi/matcher/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Matchi
+  module Matcher
+    # Abstract matcher class.
+    class Base
+      # @return [Symbol] A symbol identifying the matcher.
+      def self.to_sym
+        name.delete_prefix("Matchi::Matcher::")
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+            .to_sym
+      end
+
+      # @return [#object_id] Any value to give to the matcher.
+      attr_reader :expected
+
+      # A string containing a human-readable representation of the matcher.
+      #
+      # @return [String] The human-readable representation of the matcher.
+      def inspect
+        "#{self.class}(#{expected&.inspect})"
+      end
+
+      # Abstract matcher class.
+      #
+      # @raise [NotImplementedError] Override me inside a matcher.
+      def matches?
+        raise ::NotImplementedError, "matcher MUST respond to this method."
+      end
+
+      # Returns a string representing the matcher.
+      #
+      # @example The readable definition of a FooBar matcher.
+      #   matcher = Matchi::Matcher::FooBar.new(42)
+      #   matcher.to_s # => "foo_bar 42"
+      #
+      # @return [String] A string representing the matcher.
+      def to_s
+        [self.class.to_sym, expected&.inspect].compact.join(" ")
+      end
+    end
+  end
+end

data/lib/matchi/matcher/be_an_instance_of.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Matchi
+  module Matcher
+    # *Type/class* matcher.
+    class BeAnInstanceOf < ::Matchi::Matcher::Base
+      # Initialize the matcher with an object.
+      #
+      # @example A string matcher
+      #   Matchi::Matcher::BeAnInstanceOf.new(String)
+      #
+      # @param expected [Class] An expected class.
+      def initialize(expected)
+        super()
+        @expected = expected
+      end
+
+      # Boolean comparison between the class of the actual value and the
+      # expected class.
+      #
+      # @example Is it an instance of string?
+      #   be_an_instance_of = Matchi::Matcher::BeInstanceOf.new(String)
+      #   be_an_instance_of.matches? { "foo" } # => true
+      #
+      # @yieldreturn [#class] the actual value to compare to the expected one.
+      #
+      # @return [Boolean] Comparison between actual and expected values.
+      def matches?(*, **)
+        expected.equal?(yield.class)
+      end
+    end
+  end
+end

data/lib/matchi/matcher/be_false.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Matchi
+  module Matcher
+    # *Untruth* matcher.
+    class BeFalse < ::Matchi::Matcher::Base
+      # Boolean comparison between the actual value and the expected value.
+      #
+      # @example Is it false?
+      #   be_false = Matchi::Matcher::BeFalse.new
+      #   be_false.matches? { false } # => true
+      #
+      # @yieldreturn [#object_id] The actual value to compare to the expected
+      #   one.
+      #
+      # @return [Boolean] Comparison between actual and expected values.
+      def matches?(*, **)
+        false.equal?(yield)
+      end
+    end
+  end
+end