spectus 3.3.4 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8767313f403c0f015d1316eabbf06f124ef4ecb136f8edf3529d533602622a8c
-  data.tar.gz: 419a5c0e93edac33135d305e9e384fea7d6ca305d68f9bd268f89d4ead020d3c
+  metadata.gz: 2fea4a88991addc0a6b69ce46d6422e92df818447818975d6123848cbba9d5a7
+  data.tar.gz: 8dffb97e6e58cdf0c3e5661294238e42f5477f4e677a34868ce918156086cbdb
 SHA512:
-  metadata.gz: 368fb8f488627e6c5b225bd66416ce4a3c8f61aaab0ce0a68ec6d2f354978393299399ccc4f9ea2c8e719b336764b9b7cededa4f6f237a7e5ad9a1495deb47ef
-  data.tar.gz: a5e56d1e3c6058f6df75bea0b5d564b0eb2cb6eea620ac9d445bea29a0a45e17302cdddf7cb9b5f7d18609c0b1334527f2495eef264bfb5d9041da453ec1055e
+  metadata.gz: 9a4798a255dcf0097dcba1bac46af91552a11348513c0d4af77a00a748cb950e90b113c264404cc745af3c7dc730154ad81893d879a495450f6cda5ca4b07942
+  data.tar.gz: ba56345d554c0483ce27fd6c7d876e7837d59a53a37a9b9e6417df849e0a6047b522a2c00e7f5d4327a76c1ed3e60cea68cff5970e7dcc4718d31ed89e3e6fa4

data/README.md

@@ -38,7 +38,7 @@ qualifying it with `MUST`, `SHOULD` and `MAY`, we can draw up several scenarios:
 | Implemented & Exception   | `false`  | `false`    | `false` |
 | Not implemented           | `false`  | `false`    | `true`  |
 
-When an expectation is evaluated by Spectus,
+When an expectation is evaluated by __Spectus__,
 
 * in case of a _passed_ expectation, a `Spectus::Result::Pass` instance is _returned_;
 * in case of a _failed_ expectation, a `Spectus::Result::Fail` exception is _raised_.
@@ -78,11 +78,11 @@ end
 ```ruby
 t = Spec.new("foo")
 
-t.test_a # => Spectus::Result::Pass(actual: "FOO", error: nil, expected: "FOO", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
+t.test_a # => Spectus::Result::Pass(actual: "FOO", error: nil, expected: "FOO", got: true, matcher: :eql, negate: false, level: :MUST)
 
-t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY, valid: false)
+t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY)
 
-t.test_c # => Spectus::Result::Pass(actual: 3, error: nil, expected: 42, got: false, matcher: :equal, negate: false, level: :SHOULD, valid: false)
+t.test_c # => Spectus::Result::Pass(actual: 3, error: nil, expected: 42, got: false, matcher: :equal, negate: false, level: :SHOULD)
 ```
 
 ```ruby
@@ -90,104 +90,87 @@ t = Spec.new(4)
 
 t.test_a # => raises an exception:
 # Traceback (most recent call last):
-#         6: from ./bin/console:8:in `<main>'
-#         5: from (irb):23
-#         4: from (irb):11:in `test_a'
-#         3: from /Users/cyril/github/fixrb/spectus/lib/spectus/expectation_target.rb:34:in `MUST'
-#         2: from /Users/cyril/github/fixrb/spectus/lib/spectus/requirement_level/base.rb:38:in `call'
-#         1: from /Users/cyril/.rbenv/versions/2.7.3/lib/ruby/gems/2.7.0/gems/expresenter-1.2.1/lib/expresenter/fail.rb:19:in `with'
+#         3: from ./bin/console:8:in `<main>'
+#         2: from (irb):23
+#         1: from (irb):11:in `test_a'
 # Spectus::Result::Fail (NoMethodError: undefined method `upcase' for 4:Integer)
 
-t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for 4:Integer>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY, valid: false)
+t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for 4:Integer>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY)
 
 t.test_c # => raises an exception:
 # Traceback (most recent call last):
-#         6: from ./bin/console:8:in `<main>'
-#         5: from (irb):25
-#         4: from (irb):19:in `test_c'
-#         3: from /Users/cyril/github/fixrb/spectus/lib/spectus/expectation_target.rb:100:in `SHOULD'
-#         2: from /Users/cyril/github/fixrb/spectus/lib/spectus/requirement_level/base.rb:38:in `call'
-#         1: from /Users/cyril/.rbenv/versions/2.7.3/lib/ruby/gems/2.7.0/gems/expresenter-1.2.1/lib/expresenter/fail.rb:19:in `with'
+#         3: from ./bin/console:8:in `<main>'
+#         2: from (irb):25
+#         1: from (irb):19:in `test_c'
 # Spectus::Result::Fail (NoMethodError: undefined method `length' for 4:Integer.)
 ```
 
 ## More examples
 
-### Absolute Requirement
-
-Given the "`ルビー`" object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
+To make __Spectus__ available:
 
 ```ruby
 require "spectus"
 
 include Spectus
-
-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.
+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
-require "spectus"
+it { "🦇".size }.MUST equal 1
+# => Spectus::Result::Pass(actual: 1, error: nil, expected: 1, got: true, matcher: :equal, negate: false, level: :MUST)
+```
 
-include Spectus
+### Absolute Prohibition
 
-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 true from the false:
 
-The result of the test shows that the spec passed.
+```ruby
+it { false }.MUST_NOT be_true
+# => Spectus::Result::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
-require "spectus"
-
-include Spectus
-
-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)
+it { 0.1 + 0.2 }.SHOULD equal 0.3
+# => Spectus::Result::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
-require "spectus"
-
-include Spectus
-
-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)
+it { BOOM }.SHOULD_NOT raise_exception SystemExit
 ```
 
-There was a `TypeError` exception, the result of the test shows that the spec failed.
+```txt
+Traceback (most recent call last):
+        2: from ./bin/console:8:in `<main>'
+        1: from (irb):8
+Spectus::Result::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
-require "spectus"
-
-include Spectus
-
-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)
+it { [].blank? }.MAY be_true
+# => Spectus::Result::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.
+Damn, I forgot to load activesupport. 🤦‍♂️
+
+That said, the test is passing due to the _not-implemented-like_ raised exception: `NoMethodError`.
 
 ## Code Isolation
 
@@ -200,26 +183,22 @@ Because they may or may not be desired, each requirement level has 2 versions:
 Example of test without isolation:
 
 ```ruby
-require "spectus"
-
-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)
+# => Spectus::Result::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
-require "spectus"
-
-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)
+# => Spectus::Result::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST)
+
 greeting # => "Hello, world!"
 ```
 

data/lib/spectus.rb

@@ -33,9 +33,9 @@ require_relative File.join("spectus", "expectation_target")
 #   end
 #
 #   t = Spec.new("foo")
-#   t.test_a # => Spectus::Result::Pass(actual: "FOO", error: nil, expected: "FOO", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
-#   t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY, valid: false)
-#   t.test_c # => Spectus::Result::Pass(actual: 3, error: nil, expected: 42, got: false, matcher: :equal, negate: false, level: :SHOULD, valid: false)
+#   t.test_a # => Spectus::Result::Pass(actual: "FOO", error: nil, expected: "FOO", got: true, matcher: :eql, negate: false, level: :MUST)
+#   t.test_b # => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_true, negate: false, level: :MAY)
+#   t.test_c # => Spectus::Result::Pass(actual: 3, error: nil, expected: 42, got: false, matcher: :equal, negate: false, level: :SHOULD)
 #
 # Or even directly used like this.
 #
@@ -44,7 +44,7 @@ require_relative File.join("spectus", "expectation_target")
 #
 #   include Spectus
 #
-#   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
+#   it { 42 }.MUST equal 42 # => Spectus::Result::Pass(actual: 42, error: nil, expected: 42, got: true, matcher: :equal, negate: false, level: :MUST
 #
 # It also includes a collection of expectation matchers 🤹
 #
@@ -103,7 +103,7 @@ module Spectus
   # Expectations are built with this method.
   #
   # @example An _absolute requirement_ definition.
-  #   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
+  #   it { 42 }.MUST equal 42 # => Spectus::Result::Pass(actual: 42, error: nil, expected: 42, got: true, matcher: :equal, negate: false, level: :MUST
   #
   # @param input [Proc] The code to test.
   #

data/lib/spectus/requirement_level/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative File.join("..", "exam")
+require "test_tube"
+
 require_relative File.join("..", "result")
 
 module Spectus
@@ -12,22 +13,21 @@ module Spectus
       #
       # @param callable   [#call]     The callable object to test.
       # @param isolation  [Boolean]   Compute actual in isolation?
-      # @param negate     [Boolean]   Positive or negative assertion?
+      # @param negate     [Boolean]   Invert the matcher or not.
       # @param matcher    [#matches?] The matcher.
-      def initialize(callable:, isolation:, negate:, matcher:)
-        @negate   = negate
-        @matcher  = matcher
-
-        @exam = Exam.new(
-          callable:   callable,
+      def initialize(callable:, isolation:, matcher:, negate:)
+        @negate     = negate
+        @matcher    = matcher
+        @experiment = ::TestTube.invoke(
+          callable,
           isolation:  isolation,
-          negate:     negate,
-          matcher:    matcher
+          matcher:    matcher,
+          negate:     negate
         )
       end
 
-      # @return [#Exam] The exam.
-      attr_reader :exam
+      # @return [TestTube::Base] The experiment.
+      attr_reader :experiment
 
       # @return [#matches?] The matcher that performed a boolean comparison
       #   between the actual value and the expected value.
@@ -39,20 +39,21 @@ module Spectus
       # @return [Spectus::Result::Pass] The expectation passed.
       def call
         Result.call(pass?).with(
-          actual:   exam.actual,
-          error:    exam.exception,
+          actual:   experiment.actual,
+          error:    experiment.error,
           expected: matcher.expected,
-          got:      exam.got,
-          negate:   negate?,
-          valid:    exam.valid?,
+          got:      experiment.got,
+          level:    level,
           matcher:  matcher.class.to_sym,
-          level:    level
+          negate:   negate?
         )
       end
 
       protected
 
-      # @return [Symbol] The requirement level.
+      # Some key words for use in RFCs to indicate requirement levels.
+      #
+      # @return [:MUST, :SHOULD, :MAY] The requirement level.
       def level
         self.class.name.split("::").fetch(-1).upcase.to_sym
       end
@@ -60,7 +61,7 @@ module Spectus
       # @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?
+      # @return [Boolean] Invert the matcher or not.
       def negate?
         @negate
       end

data/lib/spectus/requirement_level/may.rb

@@ -10,7 +10,7 @@ module Spectus
       #
       # @return [Boolean] Report if the low expectation pass or fail?
       def pass?
-        super || exam.exception.is_a?(::NoMethodError)
+        super || experiment.error.is_a?(::NoMethodError)
       end
     end
   end

data/lib/spectus/requirement_level/must.rb

@@ -10,7 +10,7 @@ module Spectus
       #
       # @return [Boolean] Report if the high expectation pass or fail?
       def pass?
-        exam.valid?
+        experiment.got.equal?(true)
       end
     end
   end

data/lib/spectus/requirement_level/should.rb

@@ -10,7 +10,7 @@ module Spectus
       #
       # @return [Boolean] Report if the medium expectation pass or fail?
       def pass?
-        super || exam.exception.nil?
+        super || experiment.error.nil?
       end
     end
   end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: spectus
 version: !ruby/object:Gem::Version
-  version: 3.3.4
+  version: 3.4.0
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-16 00:00:00.000000000 Z
+date: 2021-06-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: matchi
   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: test_tube
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: brutal
   requirement: !ruby/object:Gem::Requirement
@@ -187,7 +187,6 @@ 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

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