spectus 3.0.10 → 3.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13481b61d71af90cd7460d98c76eb3e13914e2720f7364433a746571d78e63d6
-  data.tar.gz: 71843f9b4ad356df5a992494978a2275dcccafb207eebcc5067e21d04a1438c4
+  metadata.gz: 73306cc997a51543203fcfbec28fedae74de8ca9f382040db66d1c6aebbfc4bd
+  data.tar.gz: c9d9365b33cc4cca9cb54630306f9320c254a42ad64161d8a609107eeb8f95e3
 SHA512:
-  metadata.gz: 538622c03f5c9e52cda46b1c76b7c7d80ffad22e18abb6bc56a52ad371bdacb4ed292b9b6a44c29894ac1ca2ea319e22c053a448baa32aedf28ec143fa8cba11
-  data.tar.gz: 638c15fc458db6ee8cc4381b16235df22ed8c6020f56b9d79f8330f28f32af34d9a50684b8b87e43ed83bac10c7c2822a8ef98cb03407ed2edae5d584312ebbd
+  metadata.gz: 5cdfb58c6e5e3b748f8c5071f354793618a6e6e00053e3139175c5afde4cbc2fd39a419fbe516970354a6eaaee585637077d6dcc65b1d3ba7ae5412f26dcce60
+  data.tar.gz: 8211f7d6955d70067071a691bfa80b1f640930c01db4cec6433534141c3f7c7a4e386ee82c80f00941b3c6a04426d2266be7cdb416960e04c5e8a36b0f35bc95

data/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2019 Cyril Kato
+Copyright (c) 2014-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,31 +1,19 @@
 # Spectus
 
-[![Build Status](https://travis-ci.org/fixrb/spectus.svg?branch=master)][travis]
+[![Build Status](https://api.travis-ci.org/fixrb/spectus.svg?branch=main)][travis]
 [![Code Climate](https://codeclimate.com/github/fixrb/spectus/badges/gpa.svg)][codeclimate]
 [![Gem Version](https://badge.fury.io/rb/spectus.svg)][gem]
-[![Inline docs](http://inch-ci.org/github/fixrb/spectus.svg?branch=master)][inchpages]
-[![Documentation](http://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
+[![Inline docs](https://inch-ci.org/github/fixrb/spectus.svg?branch=main)][inchpages]
+[![Documentation](https://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
 
-> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)'s requirement levels, and some matchers for Ruby.
-
-## Contact
-
-* Home page: https://github.com/fixrb/spectus
-* Bugs/issues: https://github.com/fixrb/spectus/issues
-* Support: https://stackoverflow.com/questions/tagged/spectus
-
-## Rubies
-
-* [MRI](https://www.ruby-lang.org/)
-* [Rubinius](http://rubini.us/)
-* [JRuby](http://jruby.org/)
+> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)'s requirement levels 🚥
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'spectus'
+gem "spectus"
 ```
 
 And then execute:
@@ -40,6 +28,8 @@ Or install it yourself as:
 
 An expectation is an assertion that is either `true` or `false`.
 
+There are several scenarios:
+
 | Requirement levels        | **MUST** | **SHOULD** | **MAY** |
 | ------------------------- | -------- | ---------- | ------- |
 | Implemented & Matched     | `true`   | `true`     | `true`  |
@@ -47,39 +37,51 @@ An expectation is an assertion that is either `true` or `false`.
 | Implemented & Exception   | `false`  | `false`    | `false` |
 | Not implemented           | `false`  | `false`    | `true`  |
 
-## Isolation
+Thus,
 
-There are two cases:
+* when an assertion is `true`, a `Spectus::Result::Pass` instance is returned;
+* when an assertion is `false`, a `Spectus::Result::Fail` exception is raised.
 
-* when the requirement level of an expectation ends with `!`, the test is performed in isolation;
-* when the requirement level of an expectation does not end with `!`, the test is performed without isolation.
+Both results share a common interface.
 
-Example of test in isolation:
+Passed expectations can be classified as:
 
-```ruby
-greeting = 'Hello, world!'
-it { greeting.gsub!('world', 'Alice') }.MUST! eql 'Hello, Alice!'
-# => #<Spectus::Result::Pass:0x007fa5022d8760 @message="Pass: Expected \"Hello, Alice!\" to eql \"Hello, Alice!\".", @subject=#<Proc:0x007fa5022d8e18@(irb):3>, @challenge=#<Defi::Challenge:0x007fa5022d8a08 @method=:call, @args=[]>, @actual="Hello, Alice!", @expected=#<Matchi::Eql:0x007fa5022d8cb0 @expected="Hello, Alice!">, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
-greeting # => "Hello, world!"
-```
+* ✅ success
+* ⚠️ warning
+* 💡 info
+
+Failed expectations can be classified as:
+
+* ❌ failure
+* 💥 error
+
+## Code Isolation
+
+When executing expectations, side-effects may occur.
+Because they may or may not be desired, each requirement level has 2 versions:
+
+* if it does not end with `!`, its test is performed without isolation;
+* if it ends with `!`, its test is performed in isolation.
 
 Example of test without isolation:
 
 ```ruby
-greeting = 'Hello, world!'
-it { greeting.gsub!('world', 'Alice') }.MUST eql 'Hello, Alice!'
-# => #<Spectus::Result::Pass:0x007f982304d310 @message="Pass: Expected \"Hello, Alice!\" to eql \"Hello, Alice!\".", @subject=#<Proc:0x007f982304fbb0@(irb):3>, @challenge=#<Defi::Challenge:0x007f982304f890 @method=:call, @args=[]>, @actual="Hello, Alice!", @expected=#<Matchi::Eql:0x007f982304f200 @expected="Hello, Alice!">, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
+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)
 greeting # => "Hello, Alice!"
 ```
 
-## Results
-
-There are two cases:
-
-* when an expectation is `true`, an instance of `Spectus::Result::Pass` is returned;
-* when an expectation is `false`, an instance of `Spectus::Result::Fail` is raised.
+Example of test in isolation:
 
-Both instances share the same interface.
+```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)
+greeting # => "Hello, world!"
+```
 
 ## Usage
 
@@ -89,24 +91,24 @@ To begin with, let's include __Spectus__:
 include Spectus
 ```
 
-### Absolute requirement
+### Absolute Requirement
 
-Given the `"ルビー"` object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
+Given the "`ルビー`" object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
 
 ```ruby
-it { 'ルビー'.valid_encoding? }.MUST be_true
-# => #<Spectus::Result::Pass:0x007ffd7d00af50 @message="Pass: Expected true to be_true.", @subject=#<Proc:0x007ffd7d010130@(irb):2>, @challenge=#<Defi::Challenge:0x007ffd7d0116e8 @method=:call, @args=[]>, @actual=true, @expected=#<Matchi::BeTrue:0x007ffd7d012188>, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
+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)
 ```
 
 The result of the test shows that the spec passed.
 
-### Absolute prohibition
+### Absolute Prohibition
 
-Given the `"foo"` object, when it receives `length` method, then it **MUST NOT** raise the `NoMethodError` exception:
+Given the "`foo`" object, when it receives `length` method, then it **MUST NOT** raise the `NoMethodError` exception:
 
 ```ruby
-it { 'foo'.length }.MUST_NOT raise_exception NoMethodError
-# => #<Spectus::Result::Pass:0x007ffd7b890af0 @message="Pass: Expected 3 not to raise_exception NoMethodError.", @subject=#<Proc:0x007ffd7b8913b0@(irb):3>, @challenge=#<Defi::Challenge:0x007ffd7b891248 @method=:call, @args=[]>, @actual=3, @expected=#<Matchi::RaiseException:0x007ffd7b891130 @expected=NoMethodError>, @got=true, @error=nil, @level=:High, @negate=true, @valid=true>
+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)
 ```
 
 The result of the test shows that the spec passed.
@@ -117,74 +119,63 @@ Given the `BasicObject` object, when it receives `superclass` method, then it **
 
 ```ruby
 it { BasicObject.superclass }.SHOULD equal NilClass
-# => #<Spectus::Result::Pass:0x007ffd7b871a38 @message="Info: Expected nil to equal NilClass.", @subject=#<Proc:0x007ffd7b872460@(irb):4>, @challenge=#<Defi::Challenge:0x007ffd7b872370 @method=:call, @args=[]>, @actual=nil, @expected=#<Matchi::Equal:0x007ffd7b872140 @expected=NilClass>, @got=false, @error=nil, @level=:Medium, @negate=false, @valid=false>
+# => Spectus::Result::Pass(actual: nil, error: nil, expected: NilClass, got: false, matcher: :equal, negate: false, level: :SHOULD, valid: false)
 ```
 
 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
+### Not Recommended
 
-Given the `"1"` object, when it receives `+(1)` method, then it **SHOULD NOT** return the `"11"` value:
+Given the "`1`" object, when it receives `+(1)` method, then it **SHOULD NOT** return the "`11`" value:
 
 ```ruby
-it { '1' + 1 }.SHOULD_NOT eql '11'
-# Spectus::Result::Fail: Error: no implicit conversion of Fixnum into String (TypeError).
-# 	from (irb):5
-# 	from ./bin/console:7:in `<main>'
+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)
 ```
 
 There was a `TypeError` exception, the result of the test shows that the spec failed.
 
 ### Optional
 
-Given the `"foo"` object, when it receives `blank?` method, then it **MAY** be `false`:
+Given the "`foo`" object, when it receives `blank?` method, then it **MAY** be `false`:
 
 ```ruby
-it { 'foo'.blank? }.MAY be_false
-# => #<Spectus::Result::Pass:0x007ffd7bbc3cb8 @message="Info: undefined method `blank?' for \"foo\":String (NoMethodError).", @subject=#<Proc:0x007ffd7b8285b8@(irb):6>, @challenge=#<Defi::Challenge:0x007ffd7b8284f0 @method=:call, @args=[]>, @actual=nil, @expected=#<Matchi::BeFalse:0x007ffd7b828310>, @got=nil, @error=#<NoMethodError: undefined method `blank?' for "foo":String>, @level=:Low, @negate=false, @valid=false>
+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)
 ```
 
-The optional `blank?` method is not implemented (unlike in [Ruby on Rails](http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F), for instance), so the result of the test shows that the spec passed.
+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.
 
-## Security
+### More Examples
 
-As a basic form of security __Spectus__ 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.
+A full list of unit tests can be viewed (and executed) here:
+[./test.rb](https://github.com/fixrb/spectus/blob/main/test.rb)
 
-The checksum of a file can be checked using the `sha512sum` command.  For
-example:
+## Contact
 
-    $ sha512sum pkg/spectus-2.3.0.gem
-    e9e35e1953104e2d428b0f217e418db3c1baecd9e011b2545f9fcba4ff7e3bba674c6b928b3d8db842a139cd7cc9806d77ebdc7f710ece4f2aecb343703e2451  pkg/spectus-2.3.0.gem
+* Home page: https://github.com/fixrb/spectus
+* Bugs/issues: https://github.com/fixrb/spectus/issues
 
 ## Versioning
 
-__Spectus__ follows [Semantic Versioning 2.0](http://semver.org/).
+__Spectus__ follows [Semantic Versioning 2.0](https://semver.org/).
 
-## Contributing
+## License
 
-1. [Fork it](https://github.com/fixrb/spectus/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 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/spectus/raw/main/img/sashite.png"
+    alt="Sashite" /></a>
+</p>
 
 [gem]: https://rubygems.org/gems/spectus
 [travis]: https://travis-ci.org/fixrb/spectus
 [codeclimate]: https://codeclimate.com/github/fixrb/spectus
-[gemnasium]: https://gemnasium.com/fixrb/spectus
-[inchpages]: http://inch-ci.org/github/fixrb/spectus
-[rubydoc]: http://rubydoc.info/gems/spectus/frames
-
-***
-
-This project is sponsored by:
-
-[![Sashite](https://pbs.twimg.com/profile_images/618485028322975744/PZ9qPuI__400x400.png)](https://sashite.com/)
+[inchpages]: https://inch-ci.org/github/fixrb/spectus
+[rubydoc]: https://rubydoc.info/gems/spectus/frames

data/lib/spectus.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-require_relative File.join('spectus', 'matchers')
+require "matchi/helper"
 
 # Namespace for the Spectus library.
 #
-# @api public
-#
 # @example It MUST equal 42.
 #   require 'spectus'
 #   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
 module Spectus
-  include Matchers
+  include ::Matchi::Helper
 
   # Expectations are built with this method.
   #
@@ -25,4 +23,4 @@ module Spectus
   end
 end
 
-require_relative File.join('spectus', 'expectation_target')
+require_relative File.join("spectus", "expectation_target")

data/lib/spectus/exam.rb

@@ -0,0 +1,56 @@
+# 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,49 +1,49 @@
 # frozen_string_literal: true
 
-require 'defi'
-
 module Spectus
   # Wraps the target of an expectation.
   #
-  # @api public
-  #
   # @example
   #   it { actual value } # => ExpectationTarget wrapping the block
   class ExpectationTarget
-    # Create a new expection target
+    # Create a new expectation target
     #
-    # @api private
-    #
-    # @param subject [Proc] The value which is compared with the expected value.
-    def initialize(&subject)
-      @subject    = subject
-      @challenges = [block_challenge]
+    # @param callable [Proc] The object to test.
+    def initialize(&callable)
+      @callable = callable
     end
 
-    # rubocop:disable Style/MethodName
-    # rubocop:disable Naming/UncommunicativeMethodParamName
+    # rubocop:disable Naming/MethodName
 
-    # @api public
-    #
     # 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 m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MUST(m)
-      RequirementLevel::High.new(m, false, subject, *challenges).result
+    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!(m)
-      RequirementLevel::High.new(m, false, subject, *challenges).result(true)
+    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
@@ -52,19 +52,29 @@ module Spectus
     # @example _Absolute prohibition_ definition
     #   it { 'foo'.size }.MUST_NOT equal 42
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MUST_NOT(m)
-      RequirementLevel::High.new(m, true, subject, *challenges).result
+    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!(m)
-      RequirementLevel::High.new(m, true, subject, *challenges).result(true)
+    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
@@ -75,19 +85,29 @@ module Spectus
     # @example _Recommended_ definition
     #   it { 'foo'.valid_encoding? }.SHOULD equal true
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def SHOULD(m)
-      RequirementLevel::Medium.new(m, false, subject, *challenges).result
+    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!(m)
-      RequirementLevel::Medium.new(m, false, subject, *challenges).result(true)
+    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
@@ -99,19 +119,29 @@ module Spectus
     # @example _Not recommended_ definition
     #   it { ''.blank? }.SHOULD_NOT raise_exception NoMethodError
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def SHOULD_NOT(m)
-      RequirementLevel::Medium.new(m, true, subject, *challenges).result
+    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!(m)
-      RequirementLevel::Medium.new(m, true, subject, *challenges).result(true)
+    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
@@ -129,53 +159,40 @@ module Spectus
     # @example _Optional_ definition
     #   it { 'foo'.bar }.MAY match /^foo$/
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MAY(m)
-      RequirementLevel::Low.new(m, false, subject, *challenges).result
+    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!(m)
-      RequirementLevel::Low.new(m, false, subject, *challenges).result(true)
+    def MAY!(matcher)
+      RequirementLevel::May.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
-    # rubocop:enable Style/MethodName
-    # rubocop:enable Naming/UncommunicativeMethodParamName
+    # rubocop:enable Naming/MethodName
 
-    # rubocop:disable Style/AccessModifierDeclarations
+    protected
 
-    # @!attribute [r] subject
-    #
-    # @return [BasicObject] The front object to be tested.
-    attr_reader :subject
-    private :subject
-
-    # @!attribute [r] challenges
-    #
-    # @return [Array] The challenges to call on the subject.
-    attr_reader :challenges
-    private :challenges
-
-    # rubocop:enable Style/AccessModifierDeclarations
-
-    private
-
-    # The first default challenge for blocks.
-    #
-    # @since 2.10.0
-    #
-    # @return [Defi] The challenge for blocks.
-    def block_challenge
-      ::Defi.send(:call)
-    end
+    # @return [#call] The callable object to test.
+    attr_reader :callable
   end
 end
 
-require_relative File.join('requirement_level', 'high')
-require_relative File.join('requirement_level', 'medium')
-require_relative File.join('requirement_level', 'low')
+require_relative File.join("requirement_level", "must")
+require_relative File.join("requirement_level", "should")
+require_relative File.join("requirement_level", "may")