spectus 3.0.10 → 3.1.4

data/lib/spectus/requirement_level/base.rb

@@ -1,109 +1,68 @@
 # frozen_string_literal: true
 
-require 'aw'
-
 module Spectus
   # Namespace for the requirement levels.
-  #
-  # @api private
-  #
   module RequirementLevel
     # Requirement level's base class.
-    #
     class Base
       # Initialize the requirement level class.
       #
-      # @param matcher    [#matches?]   The matcher.
-      # @param negate     [Boolean]     Evaluate to a negative assertion.
-      # @param subject    [#object_id]  The front object to test.
-      # @param challenges [Array]       A list of challenges.
-      def initialize(matcher, negate, subject, *challenges)
-        @matcher    = matcher
-        @negate     = negate
-        @subject    = subject
-        @challenges = challenges
+      # @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
 
-      # @!attribute [r] matcher
-      #
-      # @return [#matches?] The matcher.
+      # @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 value of the negate instance variable.
+      # The result of the expectation.
       #
-      # @return [Boolean] Evaluated to a negative assertion or not.
-      def negate?
-        @negate
+      # @raise [Result::Fail] The expectation is `false`.
+      # @return [Result::Pass] The expectation is `true`.
+      def call
+        Result.call(pass?,
+                    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
 
-      # @!attribute [r] subject
-      #
-      # @return [#object_id] The front object to test.
-      attr_reader :subject
-
-      # @!attribute [r] challenges
-      #
-      # @return [Array] A list of challenges.
-      attr_reader :challenges
-
       protected
 
-      # @param state [Sandbox] The sandbox that tested the code.
-      #
-      # @return [Result::Pass] Pass the spec.
-      def pass!(state)
-        r = Report.new(matcher, negate?, state, true)
-
-        Result::Pass.new(r, *result_signature(state))
-      end
-
-      # @param state [Sandbox] The sandbox that tested the code.
-      #
-      # @raise [Result::Fail] Fail the spec.
-      def fail!(state)
-        r = Report.new(matcher, negate?, state, false)
-
-        raise Result::Fail.new(r, *result_signature(state)), r, caller[2..-1]
-      end
-
-      # @param state [Sandbox] The sandbox that tested the code.
-      #
-      # @return [Array] List of parameters.
-      def result_signature(state)
-        [
-          subject,
-          state.last_challenge,
-          state.actual,
-          matcher,
-          state.got,
-          state.exception,
-          level,
-          negate?,
-          state.valid?
-        ]
-      end
-
       # @return [Symbol] The requirement level.
       def level
-        self.class.name.split('::').last.to_sym
+        self.class.name.split("::").fetch(-1).upcase.to_sym
       end
 
-      # @param isolation [Boolean] Test in isolation.
+      # @note The boolean comparison between the actual value and the expected
+      #   value can be evaluated to a negative assertion.
       #
-      # @return [Sandbox] The sandbox.
-      def sandbox(isolation)
-        isolation ? ::Aw.fork! { execute } : execute
-      end
-
-      # @return [Sandbox] The sandbox.
-      def execute
-        Sandbox.new(matcher, negate?, subject, *challenges)
+      # @return [Boolean] Positive or negative assertion?
+      def negate?
+        @negate
       end
     end
   end
 end
 
-require_relative File.join('..', 'report')
-require_relative File.join('..', 'result', 'fail')
-require_relative File.join('..', 'result', 'pass')
-require_relative File.join('..', 'sandbox')
+require_relative File.join("..", "result")
+require_relative File.join("..", "exam")

data/lib/spectus/requirement_level/may.rb

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spectus
+  # Namespace for the results.
+  module Result
+    # @raise [Fail] A failed spec result.
+    # @return [Pass] A passed spec result.
+    def self.call(is_passed, **details)
+      (is_passed ? Pass : Fail).call(**details)
+    end
+  end
+end
+
+require_relative File.join("result", "fail")
+require_relative File.join("result", "pass")

data/lib/spectus/result/common.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Spectus
+  module Result
+    # Common collection of methods for Result's classes.
+    module Common
+      # @return [#object_id] Returned value by the challenged subject.
+      attr_reader :actual
+
+      # @return [Exception, nil] Any possible raised exception.
+      attr_reader :error
+
+      # @return [#object_id] The expected value.
+      attr_reader :expected
+
+      # @return [#object_id] The result of the boolean comparison between the
+      #   actual value and the expected value through the matcher.
+      attr_reader :got
+
+      # @return [#object_id] The matcher.
+      attr_reader :matcher
+
+      # @return [:MUST, :SHOULD, :MAY] The requirement level of the expectation.
+      attr_reader :level
+
+      # Common initialize method.
+      #
+      # @param actual   [#object_id] Returned value by the challenged subject.
+      # @param error    [Exception, nil] Any possible raised exception.
+      # @param expected [#object_id] The expected value.
+      # @param got      [Boolean, nil] The result of the boolean comparison
+      #   between the actual value and the expected value through the matcher.
+      # @param negate   [Boolean] Evaluated to a negative assertion?
+      # @param valid    [Boolean] Report if the test was true or false?
+      # @param matcher  [Symbol] The matcher.
+      # @param level    [:MUST, :SHOULD, :MAY] The requirement level.
+      def initialize(actual:, error:, expected:, got:, negate:, valid:,
+                     matcher:, level:)
+
+        @actual   = actual
+        @error    = error
+        @expected = expected
+        @got      = got
+        @negate   = negate
+        @valid    = valid
+        @matcher  = matcher
+        @level    = level
+
+        super(to_s) if failed?
+      end
+
+      # Did the test pass?
+      #
+      # @return [Boolean] The spec passed or failed?
+      def passed?
+        !failed?
+      end
+
+      # The value of the negate instance variable.
+      #
+      # @return [Boolean] Evaluated to a negative assertion?
+      def negate?
+        @negate
+      end
+
+      # The state of error.
+      #
+      # @return [Boolean] The test raised an error?
+      def error?
+        !error.nil?
+      end
+
+      # The state of success.
+      #
+      # @return [Boolean] The test was a success?
+      def success?
+        got.equal?(true)
+      end
+
+      # The value of the boolean comparison between the actual value and the
+      # expected value.
+      #
+      # @return [Boolean] The test was true or false?
+      def valid?
+        @valid
+      end
+
+      # A string containing a human-readable representation of the result.
+      #
+      # @return [String] The human-readable representation of the result.
+      def inspect
+        "#{self.class}(actual: #{actual.inspect}, "     \
+                      "error: #{error.inspect}, "       \
+                      "expected: #{expected.inspect}, " \
+                      "got: #{got.inspect}, "           \
+                      "matcher: #{matcher.inspect}, "   \
+                      "negate: #{negate?.inspect}, "    \
+                      "level: #{level.inspect}, "       \
+                      "valid: #{valid?.inspect})"       \
+      end
+
+      # The readable definition.
+      #
+      # @return [String] A readable string of the definition.
+      def definition
+        [matcher, expected&.inspect].compact.join(" ")
+      end
+
+      # The negation, if any.
+      #
+      # @return [String] The negation, or an empty string.
+      def maybe_negate
+        negate? ? " not" : ""
+      end
+
+      # The summary of the result.
+      #
+      # @return [String] A string representing the summary of the result.
+      def summary
+        if error?
+          error.message
+        elsif actual.is_a?(::Exception)
+          actual.message
+        elsif actual == expected
+          "expected#{maybe_negate} to #{definition}"
+        else
+          "expected #{actual.inspect}#{maybe_negate} to #{definition}"
+        end
+      end
+
+      # Express the result with one colored char.
+      #
+      # @return [String] The colored char that identify the result.
+      def colored_char
+        color(char)
+      end
+
+      # The colored string representation of the result.
+      #
+      # @return [String] A string representing the result.
+      def colored_string
+        color(to_s)
+      end
+
+      # The representation of the result.
+      #
+      # @return [String] A string representing the result.
+      def to_s
+        "#{titre}: #{summary}."
+      end
+
+      # Titre for the result.
+      #
+      # @return [String] A string representing the titre.
+      def titre
+        if error?
+          error.class.name
+        else
+          to_sym.to_s.capitalize
+        end
+      end
+
+      protected
+
+      def color(str)
+        if success?
+          "\e[32m#{str}\e[0m"
+        elsif info?
+          "\e[36m#{str}\e[0m"
+        elsif warning?
+          "\e[33m#{str}\e[0m"
+        elsif failure?
+          "\e[35m#{str}\e[0m"
+        else
+          "\e[31m#{str}\e[0m"
+        end
+      end
+    end
+  end
+end

data/lib/spectus/result/fail.rb

@@ -1,32 +1,44 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative "common"
 
 module Spectus
   module Result
     # The class that is responsible for reporting that the expectation is false.
     class Fail < ::StandardError
-      include Base
+      include Common
 
-      # The value of the expectation of the spec.
+      # @raise [Fail] A failed spec result.
+      def self.call(**details)
+        raise new(**details)
+      end
+
+      # Did the test fail?
       #
-      # @return [Boolean] The spec was false.
-      def result?
-        false
+      # @return [Boolean] The spec passed or failed?
+      def failed?
+        true
       end
 
       # The state of failure.
       #
-      # @return [Boolean] The test was a failure.
+      # @return [Boolean] The test was a failure?
       def failure?
-        error.nil?
+        !error?
+      end
+
+      # The state of info.
+      #
+      # @return [Boolean] The test was an info?
+      def info?
+        false
       end
 
-      # The state of error.
+      # The state of warning.
       #
-      # @return [Boolean] The test was an error.
-      def error?
-        !failure?
+      # @return [Boolean] The test was a warning?
+      def warning?
+        false
       end
 
       # Identify the state of the result.
@@ -38,14 +50,23 @@ module Spectus
 
       # Express the result with one char.
       #
-      # @param color [Boolean] Enable the color.
-      #
       # @return [String] The char that identify the result.
-      def to_char(color = false)
+      def char
+        if failure?
+          "F"
+        else
+          "E"
+        end
+      end
+
+      # Express the result with one emoji.
+      #
+      # @return [String] The emoji that identify the result.
+      def emoji
         if failure?
-          color ? "\e[35mF\e[0m" : 'F'
+          "❌"
         else
-          color ? "\e[31mE\e[0m" : 'E'
+          "💥"
         end
       end
     end