spectus 3.3.3 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e857c2dbe2b02d961770b40bd9119fa115665105c99f0a6eb813266e9b72be
-  data.tar.gz: 6f54bf36215f3f662257cffd68e420051f83f6de13d15d9dca60ffb7e89b9c0f
+  metadata.gz: ed1222cb49baae653e3e0650224f658c9efe61059d3a91e492db7d7a9c2b9ff4
+  data.tar.gz: 6894d5af94f3bafb3164dfa129ee3ced2914fc22edb51968ff005037c0c292be
 SHA512:
-  metadata.gz: 5d6b1e7a99bc5d6b52760a8f5fa37f58d485bda7fbf08d9790f78944375d46807366cc9c0232f5f0bb25940b668f89b8a153b78940204ee8e0c54cdc371dacd4
-  data.tar.gz: 658aaa685fe75ea3fd06c92b0ddca3066efb841cf3c0aa4b252f7d2a9f797ea9f44791ff441bc72bfc76f95fd3f3c532a8b4a1b74e40ea832f6c72ffcbff9b3d
+  metadata.gz: 07f4bc04c3c3d02874f52f1f59c9436651933c4830d456ef64895a6d94e2c4c5672e341b416a998400e43fb861e89fa721cc0879af99c89e26e09b1d5f0c7724
+  data.tar.gz: 9b7a1da40d5c191f00d4856259a8908aceb87fa73eeaaae6c447448866a73389ba23b7fd9b6b5845b5588e6adac3bd5cb0a1630ddb912752846d0d260c41f95e

data/README.md

@@ -1,11 +1,12 @@
 # Spectus
 
-[![Build Status](https://api.travis-ci.org/fixrb/spectus.svg?branch=main)][travis]
-[![Gem Version](https://badge.fury.io/rb/spectus.svg)][gem]
-[![Inline docs](https://inch-ci.org/github/fixrb/spectus.svg?branch=main)][inchpages]
-[![Documentation](https://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
+[![Version](https://img.shields.io/github/v/tag/fixrb/spectus?label=Version&logo=github)](https://github.com/fixrb/spectus/releases)
+[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/fixrb/spectus/main)
+[![CI](https://github.com/fixrb/spectus/workflows/CI/badge.svg?branch=main)](https://github.com/fixrb/spectus/actions?query=workflow%3Aci+branch%3Amain)
+[![RuboCop](https://github.com/fixrb/spectus/workflows/RuboCop/badge.svg?branch=main)](https://github.com/fixrb/spectus/actions?query=workflow%3Arubocop+branch%3Amain)
+[![License](https://img.shields.io/github/license/fixrb/spectus?label=License&logo=github)](https://github.com/fixrb/spectus/raw/main/LICENSE.md)
 
-> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)'s requirement levels 🚥
+> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt) requirement levels 🚥
 
 ## Installation
 
@@ -29,72 +30,91 @@ gem install spectus
 
 ## Usage
 
-To begin with, let's include __Spectus__:
+The __Spectus__ library is basically a module defining methods that can be used to qualify expectations in specifications.
+
+To make __Spectus__ available:
 
 ```ruby
-include Spectus
+require "spectus"
 ```
 
-### Absolute Requirement
+For convenience, we will also instantiate some matchers from the [Matchi library](https://github.com/fixrb/matchi):
 
-Given the "`ルビー`" object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
+```sh
+gem install matchi
+```
 
 ```ruby
-it { "ルビー".valid_encoding? }.MUST be_true
-# => Spectus::Result::Pass(actual: true, error: nil, expected: nil, got: true, matcher: :be_true, negate: false, level: :MUST, valid: true)
+require "matchi/helper"
+
+include Matchi::Helper
 ```
 
-The result of the test shows that the spec passed.
+All examples here assume that this has been done.
 
-### Absolute Prohibition
+### Absolute Requirement
 
-Given the "`foo`" object, when it receives `length` method, then it **MUST NOT** raise the `NoMethodError` exception:
+There's only one bat:
 
 ```ruby
-it { "foo".length }.MUST_NOT raise_exception NoMethodError
-# => Spectus::Result::Pass(actual: 3, error: nil, expected: NoMethodError, got: true, matcher: :raise_exception, negate: true, level: :MUST, valid: true)
+definition = Spectus.must equal 1
+definition.call { "🦇".size }
+# => Expresenter::Pass(actual: 1, error: nil, expected: 1, got: true, matcher: :equal, negate: false, level: :MUST
 ```
 
-The result of the test shows that the spec passed.
+### Absolute Prohibition
+
+The true from the false:
+
+```ruby
+definition = Spectus.must_not be_true
+definition.call { false }
+# => Expresenter::Pass(actual: false, error: nil, expected: nil, got: true, matcher: :be_true, negate: true, level: :MUST
+```
 
 ### Recommended
 
-Given the `BasicObject` object, when it receives `superclass` method, then it **SHOULD** return the explicit blank class `NilClass`:
+A well-known joke. An addition of `0.1` and `0.2` is deadly precise:
 
 ```ruby
-it { BasicObject.superclass }.SHOULD equal NilClass
-# => Spectus::Result::Pass(actual: nil, error: nil, expected: NilClass, got: false, matcher: :equal, negate: false, level: :SHOULD, valid: false)
+definition = Spectus.should equal 0.3
+definition.call { 0.1 + 0.2 }
+# => Expresenter::Pass(actual: 0.30000000000000004, error: nil, expected: 0.3, got: false, matcher: :equal, negate: false, level: :SHOULD
 ```
 
-Instead of the expected `NilClass` class, its sole instance (which is `nil`) was returned.
-However, because there isn't any exception, the result of the test shows that the spec passed.
-
 ### Not Recommended
 
-Given the "`1`" object, when it receives `+(1)` method, then it **SHOULD NOT** return the "`11`" value:
+The situation should still be under control:
 
 ```ruby
-it { "1" + 1 }.SHOULD_NOT eql "11"
-# raise Spectus::Result::Fail(actual: nil, error: #<TypeError: no implicit conversion of Integer into String>, expected: "11", got: nil, matcher: :eql, negate: true, level: :SHOULD, valid: false)
+definition = Spectus.should_not raise_exception SystemExit
+definition.call { BOOM }
 ```
 
-There was a `TypeError` exception, the result of the test shows that the spec failed.
+```txt
+Traceback (most recent call last):
+        6: from /Users/cyril/.rbenv/versions/2.7.3/bin/irb:23:in `<main>'
+        5: from /Users/cyril/.rbenv/versions/2.7.3/bin/irb:23:in `load'
+        4: from /Users/cyril/.rbenv/versions/2.7.3/lib/ruby/gems/2.7.0/gems/irb-1.2.6/exe/irb:11:in `<top (required)>'
+        3: from (irb):11
+        2: from /Users/cyril/.rbenv/versions/2.7.3/lib/ruby/gems/2.7.0/gems/spectus-4.0.0/lib/spectus/requirement/base.rb:32:in `call'
+        1: from /Users/cyril/.rbenv/versions/2.7.3/lib/ruby/gems/2.7.0/gems/expresenter-1.3.0/lib/expresenter/fail.rb:25:in `with'
+Expresenter::Fail (NameError: uninitialized constant BOOM.)
+```
 
 ### Optional
 
-Given the "`foo`" object, when it receives `blank?` method, then it **MAY** be `false`:
+An empty array is blank, right?
 
 ```ruby
-it { "foo".blank? }.MAY be_false
-# => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_false, negate: false, level: :MAY, valid: false)
+definition = Spectus.may be_true
+definition.call { [].blank? }
+# => Expresenter::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for []:Array>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY
 ```
 
-The optional `blank?` method is not implemented (unlike in [Ruby on Rails](https://api.rubyonrails.org/classes/Object.html#method-i-blank-3F), for instance), so the result of the test shows that the spec passed.
-
-### More Examples
+Damn, I forgot to load activesupport. 🤦‍♂️
 
-A full list of unit tests can be viewed (and executed) here:
-[./test.rb](https://github.com/fixrb/spectus/blob/main/test.rb)
+That said, the test is passing due to the _not-implemented-like_ raised exception: `NoMethodError`.
 
 ## Code Isolation
 
@@ -107,20 +127,24 @@ Because they may or may not be desired, each requirement level has 2 versions:
 Example of test without isolation:
 
 ```ruby
-include Spectus
 greeting = "Hello, world!"
-it { greeting.gsub!("world", "Alice") }.MUST eql "Hello, Alice!"
-# => Spectus::Result::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
+
+definition = Spectus.must eql "Hello, Alice!"
+definition.call { greeting.gsub!("world", "Alice") }
+# => Expresenter::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST
+
 greeting # => "Hello, Alice!"
 ```
 
 Example of test in isolation:
 
 ```ruby
-include Spectus
 greeting = "Hello, world!"
-it { greeting.gsub!("world", "Alice") }.MUST! eql "Hello, Alice!"
-# => Spectus::Result::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
+
+definition = Spectus.must! eql "Hello, Alice!"
+definition.call { greeting.gsub!("world", "Alice") }
+# => Expresenter::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST
+
 greeting # => "Hello, world!"
 ```
 
@@ -128,6 +152,7 @@ greeting # => "Hello, world!"
 
 * Home page: https://github.com/fixrb/spectus
 * Bugs/issues: https://github.com/fixrb/spectus/issues
+* Blog post: https://batman.buzz/a-spectus-tutorial-expectations-with-rfc-2119-compliance-1fc769861c1
 
 ## Versioning
 
@@ -135,7 +160,7 @@ __Spectus__ follows [Semantic Versioning 2.0](https://semver.org/).
 
 ## License
 
-The [gem](https://rubygems.org/gems/spectus) is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The [gem](https://rubygems.org/gems/spectus) is available as open source under the terms of the [MIT License](https://github.com/fixrb/spectus/raw/main/LICENSE.md).
 
 ***
 
@@ -145,8 +170,3 @@ The [gem](https://rubygems.org/gems/spectus) is available as open source under t
     src="https://github.com/fixrb/spectus/raw/main/img/sashite.png"
     alt="Sashite" /></a>
 </p>
-
-[gem]: https://rubygems.org/gems/spectus
-[travis]: https://travis-ci.org/fixrb/spectus
-[inchpages]: https://inch-ci.org/github/fixrb/spectus
-[rubydoc]: https://rubydoc.info/gems/spectus/frames

data/lib/spectus.rb

@@ -1,26 +1,226 @@
 # frozen_string_literal: true
 
-require "matchi/helper"
+require_relative File.join("spectus", "requirement")
 
 # Namespace for the Spectus library.
 #
-# @example It MUST equal 42.
-#   require 'spectus'
-#   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
+# This module defines methods that can be used to qualify expectations in
+# specifications.
 module Spectus
-  include ::Matchi::Helper
+  # This method mean that the definition is an absolute requirement of the specification.
+  #
+  # @example An absolute requirement definition
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.must eql "FOO"
+  #   # => #<MUST Matchi::Matcher::Eql("FOO") isolate=false negate=false>
+  #
+  # @param matcher [#matches?] The matcher.
+  #
+  # @return [Requirement::Required] An absolute requirement level instance.
+  #
+  # @api public
+  def self.must(matcher)
+    Requirement::Required.new(
+      isolate: false,
+      negate:  false,
+      matcher: matcher
+    )
+  end
 
-  # Expectations are built with this method.
+  # @example An absolute requirement definition with isolation
+  #   require "spectus"
+  #   require "matchi/helper"
   #
-  # @example An _absolute requirement_ definition.
-  #   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
+  #   include Matchi::Helper
   #
-  # @param input [Proc] The code to test.
+  #   Spectus.must! eql "FOO"
+  #   # => #<MUST Matchi::Matcher::Eql("FOO") isolate=true negate=false>
   #
-  # @return [ExpectationTarget] The expectation target.
-  def it(&input)
-    ExpectationTarget.new(&input)
+  # @see must
+  def self.must!(matcher)
+    Requirement::Required.new(
+      isolate: true,
+      negate:  false,
+      matcher: matcher
+    )
+  end
+
+  # This method mean that the definition is an absolute prohibition of the specification.
+  #
+  # @example An absolute prohibition definition
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.must_not equal 42
+  #   # => #<MUST Matchi::Matcher::Equal(42) isolate=false negate=true>
+  #
+  # @param matcher [#matches?] The matcher.
+  #
+  # @return [Requirement::Required] An absolute prohibition level instance.
+  def self.must_not(matcher)
+    Requirement::Required.new(
+      isolate: false,
+      negate:  true,
+      matcher: matcher
+    )
+  end
+
+  # @example An absolute prohibition definition with isolation
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.must_not! equal 42
+  #   # => #<MUST Matchi::Matcher::Equal(42) isolate=true negate=true>
+  #
+  # @see must_not
+  def self.must_not!(matcher)
+    Requirement::Required.new(
+      isolate: true,
+      negate:  true,
+      matcher: matcher
+    )
+  end
+
+  # This method mean that there may exist valid reasons in particular
+  # circumstances to ignore a particular item, but the full implications must be
+  # understood and carefully weighed before choosing a different course.
+  #
+  # @example A recommended definition
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.should equal true
+  #   # => #<SHOULD Matchi::Matcher::Equal(true) isolate=false negate=false>
+  #
+  # @param matcher [#matches?] The matcher.
+  #
+  # @return [Requirement::Recommended] A recommended requirement level instance.
+  def self.should(matcher)
+    Requirement::Recommended.new(
+      isolate: false,
+      negate:  false,
+      matcher: matcher
+    )
+  end
+
+  # @example A recommended definition with isolation
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.should! equal true
+  #   # => #<SHOULD Matchi::Matcher::Equal(true) isolate=true negate=false>
+  #
+  # @see should
+  def self.should!(matcher)
+    Requirement::Recommended.new(
+      isolate: true,
+      negate:  false,
+      matcher: matcher
+    )
+  end
+
+  # This method mean that there may exist valid reasons in particular
+  # circumstances when the particular behavior is acceptable or even useful, but
+  # the full implications should be understood and the case carefully weighed
+  # before implementing any behavior described with this label.
+  #
+  # @example A not recommended definition
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.should_not raise_exception NoMethodError
+  #   # => #<SHOULD Matchi::Matcher::RaiseException(NoMethodError) isolate=false negate=true>
+  #
+  # @param matcher [#matches?] The matcher.
+  #
+  # @return [Requirement::Recommended] A not recommended requirement level
+  #   instance.
+  def self.should_not(matcher)
+    Requirement::Recommended.new(
+      isolate: false,
+      negate:  true,
+      matcher: matcher
+    )
+  end
+
+  # @example A not recommended definition with isolation
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.should_not! raise_exception NoMethodError
+  #   # => #<SHOULD Matchi::Matcher::RaiseException(NoMethodError) isolate=true negate=true>
+  #
+  # @see should_not
+  def self.should_not!(matcher)
+    Requirement::Recommended.new(
+      isolate: true,
+      negate:  true,
+      matcher: matcher
+    )
+  end
+
+  # This method mean that an item is truly optional.
+  # One vendor may choose to include the item because a particular marketplace
+  # requires it or because the vendor feels that it enhances the product while
+  # another vendor may omit the same item. An implementation which does not
+  # include a particular option must be prepared to interoperate with another
+  # implementation which does include the option, though perhaps with reduced
+  # functionality. In the same vein an implementation which does include a
+  # particular option must be prepared to interoperate with another
+  # implementation which does not include the option (except, of course, for the
+  # feature the option provides).
+  #
+  # @example An optional definition
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.may match /^foo$/
+  #   # => #<MAY Matchi::Matcher::Match(/^foo$/) isolate=false negate=false>
+  #
+  # @param matcher [#matches?] The matcher.
+  #
+  # @return [Requirement::Optional] An optional requirement level instance.
+  def self.may(matcher)
+    Requirement::Optional.new(
+      isolate: false,
+      negate:  false,
+      matcher: matcher
+    )
   end
-end
 
-require_relative File.join("spectus", "expectation_target")
+  # @example An optional definition with isolation
+  #   require "spectus"
+  #   require "matchi/helper"
+  #
+  #   include Matchi::Helper
+  #
+  #   Spectus.may! match /^foo$/
+  #   # => #<MAY Matchi::Matcher::Match(/^foo$/) isolate=true negate=false>
+  #
+  # @see may
+  def self.may!(matcher)
+    Requirement::Optional.new(
+      isolate: true,
+      negate:  false,
+      matcher: matcher
+    )
+  end
+end

data/lib/spectus/requirement.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spectus
+  # Namespace for the results.
+  #
+  # @api private
+  module Requirement
+  end
+end
+
+require_relative File.join("requirement", "required")
+require_relative File.join("requirement", "recommended")
+require_relative File.join("requirement", "optional")

data/lib/spectus/requirement/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "expresenter"
+require "test_tube"
+
+module Spectus
+  # Namespace for the requirement levels.
+  module Requirement
+    # Requirement level's base class.
+    class Base
+      # Initialize the requirement level class.
+      #
+      # @param isolate  [Boolean]   Compute actual in a subprocess.
+      # @param matcher  [#matches?] The matcher.
+      # @param negate   [Boolean]   Invert the matcher or not.
+      def initialize(isolate:, matcher:, negate:)
+        @isolate  = isolate
+        @matcher  = matcher
+        @negate   = negate
+      end
+
+      # Test result.
+      #
+      # @raise [::Expresenter::Fail] A failed spec exception.
+      # @return [::Expresenter::Pass] A passed spec instance.
+      #
+      # @see https://github.com/fixrb/expresenter
+      #
+      # @api public
+      def call(&block)
+        test = ::TestTube.invoke(isolate: @isolate, matcher: @matcher, negate: @negate, &block)
+
+        ::Expresenter.call(passed?(test)).with(
+          actual:   test.actual,
+          error:    test.error,
+          expected: @matcher.expected,
+          got:      test.got,
+          level:    self.class.level,
+          matcher:  @matcher.class.to_sym,
+          negate:   @negate
+        )
+      end
+
+      # :nocov:
+
+      # A string containing a human-readable representation of the definition.
+      #
+      # @example The human-readable representation of an absolute requirement.
+      #   require "spectus"
+      #   require "matchi/helper"
+      #
+      #   include Matchi::Helper
+      #
+      #   definition = Spectus.must equal 1
+      #   definition.inspect
+      #   # => #<MUST Matchi::Matcher::Equal(1) isolate=false negate=false>
+      #
+      # @return [String] The human-readable representation of the definition.
+      #
+      # @api public
+      def inspect
+        "#<#{self.class.level} #{@matcher.inspect} isolate=#{@isolate} negate=#{@negate}>"
+      end
+
+      # :nocov:
+
+      private
+
+      # Code experiment result.
+      #
+      # @param test [::TestTube::Base] The state of the experiment.
+      #
+      # @see https://github.com/fixrb/test_tube
+      #
+      # @return [Boolean] The result of the test (passed or failed).
+      def passed?(test)
+        test.got.equal?(true)
+      end
+    end
+  end
+end

data/lib/spectus/requirement/optional.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Spectus
+  module Requirement
+    # Optional requirement level.
+    class Optional < Base
+      # Key word for use in RFCs to indicate requirement levels.
+      #
+      # @return [Symbol] The requirement level.
+      def self.level
+        :MAY
+      end
+
+      private
+
+      # Code experiment result.
+      #
+      # @param (see Base#passed?)
+      #
+      # @return (see Base#passed?)
+      def passed?(test)
+        super || test.error.is_a?(::NoMethodError)
+      end
+    end
+  end
+end

data/lib/spectus/requirement/recommended.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Spectus
+  module Requirement
+    # Recommended and not recommended requirement levels.
+    class Recommended < Base
+      # Key word for use in RFCs to indicate requirement levels.
+      #
+      # @return [Symbol] The requirement level.
+      def self.level
+        :SHOULD
+      end
+
+      private
+
+      # Code experiment result.
+      #
+      # @param (see Base#passed?)
+      #
+      # @return (see Base#passed?)
+      def passed?(test)
+        super || test.error.nil?
+      end
+    end
+  end
+end

data/lib/spectus/requirement/required.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Spectus
+  module Requirement
+    # Absolute requirement and absolute prohibition levels.
+    class Required < Base
+      # Key word for use in RFCs to indicate requirement levels.
+      #
+      # @return [Symbol] The requirement level.
+      def self.level
+        :MUST
+      end
+    end
+  end
+end

metadata

@@ -1,59 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: spectus
 version: !ruby/object:Gem::Version
-  version: 3.3.3
+  version: 4.0.1
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-10 00:00:00.000000000 Z
+date: 2021-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: defi
+  name: expresenter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
-  name: expresenter
+  name: test_tube
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
-  name: matchi
+  name: brutal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: brutal
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: matchi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -187,15 +187,11 @@ files:
 - LICENSE.md
 - README.md
 - lib/spectus.rb
-- lib/spectus/exam.rb
-- lib/spectus/expectation_target.rb
-- lib/spectus/requirement_level/base.rb
-- lib/spectus/requirement_level/may.rb
-- lib/spectus/requirement_level/must.rb
-- lib/spectus/requirement_level/should.rb
-- lib/spectus/result.rb
-- lib/spectus/result/fail.rb
-- lib/spectus/result/pass.rb
+- lib/spectus/requirement.rb
+- lib/spectus/requirement/base.rb
+- lib/spectus/requirement/optional.rb
+- lib/spectus/requirement/recommended.rb
+- lib/spectus/requirement/required.rb
 homepage: https://github.com/fixrb/spectus
 licenses:
 - MIT

data/lib/spectus/exam.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "defi"
-
-module Spectus
-  # This class evaluate the expectation with the passed block.
-  class Exam
-    # Execute the untested code from the passed block against the matcher.
-    #
-    # rubocop:disable Lint/RescueException
-    #
-    # @param callable   [#call]     The callable object to test.
-    # @param isolation  [Boolean]   Compute actual in isolation?
-    # @param negate     [Boolean]   Positive or negative assertion?
-    # @param matcher    [#matches?] The matcher.
-    def initialize(callable:, isolation:, negate:, matcher:)
-      @got = negate ^ matcher.matches? do
-        value = if isolation
-                  send_call.to!(callable)
-                else
-                  send_call.to(callable)
-                end
-
-        @actual = value.object
-
-        value.call
-      end
-    rescue ::Exception => e
-      @actual     = nil
-      @exception  = e
-    end
-    # rubocop:enable Lint/RescueException
-
-    # @return [#object_id] The actual value.
-    attr_reader :actual
-
-    # @return [Exception, nil] An exception.
-    attr_reader :exception
-
-    # @return [Boolean, nil] Report to the spec requirement level if the
-    #   expectation is true or false.
-    attr_reader :got
-
-    # @return [Defi::Challenge] The challenge for the callable object.
-    def send_call
-      ::Defi.send(:call)
-    end
-
-    # Report to the spec requirement level if the test pass or fail.
-    #
-    # @return [Boolean] Report if the test pass or fail?
-    def valid?
-      exception.nil? ? got : false
-    end
-  end
-end

data/lib/spectus/expectation_target.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module Spectus
-  # Wraps the target of an expectation.
-  #
-  # @example
-  #   it { actual value } # => ExpectationTarget wrapping the block
-  class ExpectationTarget
-    # Create a new expectation target
-    #
-    # @param callable [Proc] The object to test.
-    def initialize(&callable)
-      @callable = callable
-    end
-
-    # rubocop:disable Naming/MethodName
-
-    # This word, or the terms "REQUIRED" or "SHALL", mean that the
-    # definition is an absolute requirement of the specification.
-    #
-    # @example _Absolute requirement_ definition
-    #   it { "foo".upcase }.MUST eql 'FOO'
-    #
-    # @param matcher [#matches?] The matcher.
-    #
-    # @return [Spectus::Result::Fail, Spectus::Result::Pass] Report if the spec
-    #   pass or fail.
-    def MUST(matcher)
-      RequirementLevel::Must.new(
-        callable:   callable,
-        isolation:  false,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # @example _Absolute requirement_ definition with isolation
-    #   it { "foo".upcase }.MUST! eql 'FOO'
-    #
-    # @see MUST
-    def MUST!(matcher)
-      RequirementLevel::Must.new(
-        callable:   callable,
-        isolation:  true,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # This phrase, or the phrase "SHALL NOT", mean that the
-    # definition is an absolute prohibition of the specification.
-    #
-    # @example _Absolute prohibition_ definition
-    #   it { "foo".size }.MUST_NOT equal 42
-    #
-    # @param matcher [#matches?] The matcher.
-    #
-    # @return [Spectus::Result::Fail, Spectus::Result::Pass] Report if the spec
-    #   pass or fail.
-    def MUST_NOT(matcher)
-      RequirementLevel::Must.new(
-        callable:   callable,
-        isolation:  false,
-        negate:     true,
-        matcher:    matcher
-      ).call
-    end
-
-    # @example _Absolute prohibition_ definition with isolation
-    #   it { "foo".size }.MUST_NOT! equal 42
-    #
-    # @see MUST_NOT
-    def MUST_NOT!(matcher)
-      RequirementLevel::Must.new(
-        callable:   callable,
-        isolation:  true,
-        negate:     true,
-        matcher:    matcher
-      ).call
-    end
-
-    # This word, or the adjective "RECOMMENDED", mean that there
-    # may exist valid reasons in particular circumstances to ignore a
-    # particular item, but the full implications must be understood and
-    # carefully weighed before choosing a different course.
-    #
-    # @example _Recommended_ definition
-    #   it { "foo".valid_encoding? }.SHOULD equal true
-    #
-    # @param matcher [#matches?] The matcher.
-    #
-    # @return [Spectus::Result::Fail, Spectus::Result::Pass] Report if the spec
-    #   pass or fail.
-    def SHOULD(matcher)
-      RequirementLevel::Should.new(
-        callable:   callable,
-        isolation:  false,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # @example _Recommended_ definition with isolation
-    #   it { "foo".valid_encoding? }.SHOULD! equal true
-    #
-    # @see SHOULD
-    def SHOULD!(matcher)
-      RequirementLevel::Should.new(
-        callable:   callable,
-        isolation:  true,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # This phrase, or the phrase "NOT RECOMMENDED" mean that
-    # there may exist valid reasons in particular circumstances when the
-    # particular behavior is acceptable or even useful, but the full
-    # implications should be understood and the case carefully weighed
-    # before implementing any behavior described with this label.
-    #
-    # @example _Not recommended_ definition
-    #   it { "".blank? }.SHOULD_NOT raise_exception NoMethodError
-    #
-    # @param matcher [#matches?] The matcher.
-    #
-    # @return [Spectus::Result::Fail, Spectus::Result::Pass] Report if the spec
-    #   pass or fail.
-    def SHOULD_NOT(matcher)
-      RequirementLevel::Should.new(
-        callable:   callable,
-        isolation:  false,
-        negate:     true,
-        matcher:    matcher
-      ).call
-    end
-
-    # @example _Not recommended_ definition with isolation
-    #   it { "".blank? }.SHOULD_NOT! raise_exception NoMethodError
-    #
-    # @see SHOULD_NOT
-    def SHOULD_NOT!(matcher)
-      RequirementLevel::Should.new(
-        callable:   callable,
-        isolation:  true,
-        negate:     true,
-        matcher:    matcher
-      ).call
-    end
-
-    # This word, or the adjective "OPTIONAL", mean that an item is
-    # truly optional.  One vendor may choose to include the item because a
-    # particular marketplace requires it or because the vendor feels that
-    # it enhances the product while another vendor may omit the same item.
-    # An implementation which does not include a particular option MUST be
-    # prepared to interoperate with another implementation which does
-    # include the option, though perhaps with reduced functionality. In the
-    # same vein an implementation which does include a particular option
-    # MUST be prepared to interoperate with another implementation which
-    # does not include the option (except, of course, for the feature the
-    # option provides.)
-    #
-    # @example _Optional_ definition
-    #   it { "foo".bar }.MAY match /^foo$/
-    #
-    # @param matcher [#matches?] The matcher.
-    #
-    # @return [Spectus::Result::Fail, Spectus::Result::Pass] Report if the spec pass or fail.
-    def MAY(matcher)
-      RequirementLevel::May.new(
-        callable:   callable,
-        isolation:  false,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # @example _Optional_ definition with isolation
-    #   it { "foo".bar }.MAY! match /^foo$/
-    #
-    # @see MAY
-    def MAY!(matcher)
-      RequirementLevel::May.new(
-        callable:   callable,
-        isolation:  true,
-        negate:     false,
-        matcher:    matcher
-      ).call
-    end
-
-    # rubocop:enable Naming/MethodName
-
-    protected
-
-    # @return [#call] The callable object to test.
-    attr_reader :callable
-  end
-end
-
-require_relative File.join("requirement_level", "must")
-require_relative File.join("requirement_level", "should")
-require_relative File.join("requirement_level", "may")

data/lib/spectus/requirement_level/base.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Spectus
-  # Namespace for the requirement levels.
-  module RequirementLevel
-    # Requirement level's base class.
-    class Base
-      # Initialize the requirement level class.
-      #
-      # @param callable   [#call]     The callable object to test.
-      # @param isolation  [Boolean]   Compute actual in isolation?
-      # @param negate     [Boolean]   Positive or negative assertion?
-      # @param matcher    [#matches?] The matcher.
-      def initialize(callable:, isolation:, negate:, matcher:)
-        @negate   = negate
-        @matcher  = matcher
-
-        @exam = Exam.new(
-          callable:   callable,
-          isolation:  isolation,
-          negate:     negate,
-          matcher:    matcher
-        )
-      end
-
-      # @return [#Exam] The exam.
-      attr_reader :exam
-
-      # @return [#matches?] The matcher that performed a boolean comparison
-      #   between the actual value and the expected value.
-      attr_reader :matcher
-
-      # The result of the expectation.
-      #
-      # @raise [Spectus::Result::Fail] The expectation is `false`.
-      # @return [Spectus::Result::Pass] The expectation is `true`.
-      def call
-        Result.call(pass?).with(
-          actual:   exam.actual,
-          error:    exam.exception,
-          expected: matcher.expected,
-          got:      exam.got,
-          negate:   negate?,
-          valid:    exam.valid?,
-          matcher:  matcher.class.to_sym,
-          level:    level
-        )
-      end
-
-      protected
-
-      # @return [Symbol] The requirement level.
-      def level
-        self.class.name.split("::").fetch(-1).upcase.to_sym
-      end
-
-      # @note The boolean comparison between the actual value and the expected
-      #   value can be evaluated to a negative assertion.
-      #
-      # @return [Boolean] Positive or negative assertion?
-      def negate?
-        @negate
-      end
-    end
-  end
-end
-
-require_relative File.join("..", "exam")
-require_relative File.join("..", "result")

data/lib/spectus/requirement_level/may.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "must"
-
-module Spectus
-  module RequirementLevel
-    # May requirement level's class.
-    class May < Must
-      # Evaluate the expectation.
-      #
-      # @return [Boolean] Report if the low expectation pass or fail?
-      def pass?
-        super || exam.exception.is_a?(::NoMethodError)
-      end
-    end
-  end
-end

data/lib/spectus/requirement_level/must.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Spectus
-  module RequirementLevel
-    # Must requirement level's class.
-    class Must < Base
-      # Evaluate the expectation.
-      #
-      # @return [Boolean] Report if the high expectation pass or fail?
-      def pass?
-        exam.valid?
-      end
-    end
-  end
-end

data/lib/spectus/requirement_level/should.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "must"
-
-module Spectus
-  module RequirementLevel
-    # Should requirement level's class.
-    class Should < Must
-      # Evaluate the expectation.
-      #
-      # @return [Boolean] Report if the medium expectation pass or fail?
-      def pass?
-        super || exam.exception.nil?
-      end
-    end
-  end
-end

data/lib/spectus/result.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Spectus
-  # Namespace for the results.
-  module Result
-    # @param is_passed [Boolean] The value of an assertion.
-    # @return [Class<Spectus::Result::Pass>, Class<Spectus::Result::Fail>] The
-    #   class of the result.
-    # @example Get the pass class result.
-    #   call(true) # => Pass
-    def self.call(is_passed)
-      is_passed ? Pass : Fail
-    end
-  end
-end
-
-require_relative File.join("result", "fail")
-require_relative File.join("result", "pass")

data/lib/spectus/result/fail.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "expresenter/fail"
-
-module Spectus
-  module Result
-    # The class that is responsible for reporting that the expectation is false.
-    class Fail < ::Expresenter::Fail
-    end
-  end
-end

data/lib/spectus/result/pass.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "expresenter/pass"
-
-module Spectus
-  module Result
-    # The class that is responsible for reporting that the expectation is true.
-    class Pass < ::Expresenter::Pass
-    end
-  end
-end