rspec-sleeping_king_studios 2.7.0 → 2.8.0.rc.0

data/lib/rspec/sleeping_king_studios/matchers/built_in/include_matcher.rb

@@ -1,11 +1,11 @@
-# lib/rspec/sleeping_king_studios/matchers/built_in/include_matcher.rb
+# frozen_string_literal: true
 
 require 'rspec/sleeping_king_studios/matchers/built_in'
 require 'rspec/sleeping_king_studios/matchers/description'
 
 module RSpec::SleepingKingStudios::Matchers::BuiltIn
   # Extensions to the built-in RSpec #include matcher.
-  class IncludeMatcher < RSpec::Matchers::BuiltIn::Include
+  class IncludeMatcher < RSpec::Matchers::BuiltIn::Include # rubocop:disable Metrics/ClassLength
     include RSpec::SleepingKingStudios::Matchers::Description
 
     # @param [Array<Hash, Proc, Object>] expected the items expected to be
@@ -16,35 +16,30 @@ module RSpec::SleepingKingStudios::Matchers::BuiltIn
     # @yieldparam [Object] item An item from the actual object; yield(item)
     #   should return true if and only if the item matches the desired
     #   predicate.
-    def initialize *expected, &block
+    def initialize(*expected, &block) # rubocop:disable Metrics/MethodLength
       if block_given?
         SleepingKingStudios::Tools::CoreTools
           .deprecate('IncludeMatcher with a block')
 
-          expected << block
+        expected << block
       end
 
       if expected.empty? && !allow_empty_matcher?
         raise ArgumentError,
           'must specify an item expectation',
           caller
-      end # if
+      end
 
-      super *expected
-    end # constructor
+      super(*expected)
+    end
 
     # (see BaseMatcher#description)
     def description
       desc = super
 
-      # Format hash expectations.
-      desc = desc.gsub(/(\S)=>(\S)/, '\1 => \2')
-
       # Replace processed block expectation stub with proper description.
-      desc = desc.gsub ':__block_comparison__', 'an item matching the block'
-
-      desc
-    end # method description
+      desc.gsub ':__block_comparison__', 'an item matching the block'
+    end
 
     # @api private
     #
@@ -53,7 +48,7 @@ module RSpec::SleepingKingStudios::Matchers::BuiltIn
       @actual = actual
 
       perform_match(actual) { |v| v }
-    end # method matches?
+    end
 
     # @api private
     #
@@ -61,93 +56,113 @@ module RSpec::SleepingKingStudios::Matchers::BuiltIn
     def does_not_match?(actual)
       @actual = actual
 
-      perform_match(actual) { |v| !v }
-    end # method does_not_match?
+      perform_match(actual, &:!)
+    end
 
     # (see BaseMatcher#failure_message)
     def failure_message
       message = super.sub ':__block_comparison__', 'an item matching the block'
 
-      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
+      unless actual.respond_to?(:include?) || message =~ /does not respond to/
+        message << ', but it does not respond to `include?`'
+      end
 
       message
-    end # method failure_message_for_should
+    end
 
     # (see BaseMatcher#failure_message_when_negated)
     def failure_message_when_negated
       message = super.sub ':__block_comparison__', 'an item matching the block'
 
-      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
+      unless actual.respond_to?(:include?) || message =~ /does not respond to/
+        message << ', but it does not respond to `include?`'
+      end
 
       message
-    end # method
+    end
 
     private
 
-    def actual_matches_proc? expected_item
+    def actual_matches_proc?(expected_item)
       if actual.respond_to?(:detect)
         !!actual.detect(&expected_item)
       else
         !!expected_item.call(actual)
-      end # if-else
-    end # method actual_matches_proc?
+      end
+    end
 
+    # @deprecated [3.0] Will be removed in version 3.0.
     def allow_empty_matcher?
-      RSpec.configure { |config| config.sleeping_king_studios.matchers }.allow_empty_include_matchers?
-    end # method strict_matching?
+      return false unless RSpec::Expectations::Version::STRING < '3.12.2'
 
-    def comparing_proc? expected_item
+      RSpec
+        .configure { |config| config.sleeping_king_studios.matchers }
+        .allow_empty_include_matchers?
+    end
+
+    def comparing_proc?(expected_item)
       expected_item.is_a?(Proc)
-    end # method comparing_proc?
+    end
+
+    def expected_items_for_description
+      items = defined?(expecteds) ? expecteds : @expected
+
+      # Preprocess items to stub out block expectations.
+      items.map { |item| item.is_a?(Proc) ? :__block_comparison__ : item }
+    end
 
-    def excluded_from_actual
+    def find_excluded_items(&)
       items = defined?(expecteds) ? expecteds : expected
 
       return [] unless @actual.respond_to?(:include?)
 
-      items.inject([]) do |memo, expected_item|
-        if comparing_proc?(expected_item)
-          memo << :__block_comparison__ unless yield actual_matches_proc?(expected_item)
-        elsif comparing_hash_to_a_subset?(expected_item)
-          expected_item.each do |(key, value)|
-            memo << { key => value } unless yield actual_hash_includes?(key, value)
-          end # each
-        elsif comparing_hash_keys?(expected_item)
-          memo << expected_item unless yield actual_hash_has_key?(expected_item)
-        else
-          memo << expected_item unless yield actual_collection_includes?(expected_item)
-        end # if-elsif-else
-
-        memo
-      end # inject
-    end # method excluded_from_actual
+      items.each.with_object([]) do |expected_item, excluded_items|
+        match_excluded_item(expected_item, excluded_items, &)
+      end
+    end
 
-    def expected_items_for_description
-      items = defined?(expecteds) ? expecteds : @expected
+    def match_excluded_hash_keys(expected_item, excluded_items)
+      return if yield actual_hash_has_key?(expected_item)
 
-      # Preprocess items to stub out block expectations.
-      items.map { |item| item.is_a?(Proc) ? :__block_comparison__ : item }
-    end # method expected_items_for_description
+      excluded_items << expected_item
+    end
 
-    def perform_match(actual, &block)
-      @actual = actual
-      @divergent_items = excluded_from_actual(&block)
-      actual.respond_to?(:include?) && @divergent_items.empty?
-    end # method perform_match
+    def match_excluded_hash_subset(expected_item, excluded_items)
+      expected_item.each do |(key, value)|
+        next if yield actual_hash_includes?(key, value)
 
-    # @api private
-    #
-    # Converts the expected item to a human-readable string. Retained for
-    # pre-3.3 compatibility.
-    def to_word expected_item
-      case
-      when is_matcher_with_description?(expected_item)
-        expected_item.description
-      when Proc === expected_item
-        "an item matching the block"
+        excluded_items << { key => value }
+      end
+    end
+
+    def match_excluded_item(expected_item, excluded_items, &)
+      if comparing_proc?(expected_item)
+        match_excluded_proc(expected_item, excluded_items, &)
+      elsif comparing_hash_to_a_subset?(expected_item)
+        match_excluded_hash_subset(expected_item, excluded_items, &)
+      elsif comparing_hash_keys?(expected_item)
+        match_excluded_hash_keys(expected_item, excluded_items, &)
       else
-        expected_item.inspect
-      end # case
-    end # method to_word
-  end # class
-end # module
+        match_excluded_value(expected_item, excluded_items, &)
+      end
+    end
+
+    def match_excluded_proc(expected_item, excluded_items)
+      return if yield actual_matches_proc?(expected_item)
+
+      excluded_items << :__block_comparison__
+    end
+
+    def match_excluded_value(expected_item, excluded_items)
+      return if yield actual_collection_includes?(expected_item)
+
+      excluded_items << expected_item
+    end
+
+    def perform_match(actual, &)
+      @actual = actual
+      @divergent_items = find_excluded_items(&)
+      actual.respond_to?(:include?) && @divergent_items.empty?
+    end
+  end
+end

data/lib/rspec/sleeping_king_studios/matchers/core/deep_matcher.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require 'hashdiff'
 
@@ -9,26 +9,28 @@ module RSpec::SleepingKingStudios::Matchers::Core
   # Matcher for performing a deep comparison between two objects.
   #
   # @since 2.5.0
-  class DeepMatcher < RSpec::SleepingKingStudios::Matchers::BaseMatcher
-    # @param [Object] expected The expected object.
+  class DeepMatcher < RSpec::SleepingKingStudios::Matchers::BaseMatcher # rubocop:disable Metrics/ClassLength
+    # @param [Object] expected the expected object.
     def initialize(expected)
+      super()
+
       @expected = expected
     end
 
     # (see BaseMatcher#description)
     def description
       "match #{format_expected(@expected)}"
-    end # method description
+    end
 
     # Inverse of #matches? method.
     #
-    # @param [Object] actual The object to check.
+    # @param [Object] actual the object to check.
     #
     # @return [Boolean] true if the actual object does not match the
     #   expectation, otherwise true.
     #
     # @see #matches?
-    def does_not_match? actual
+    def does_not_match?(actual) # rubocop:disable Metrics/MethodLength
       super
 
       if matcher?(@expected)
@@ -45,12 +47,12 @@ module RSpec::SleepingKingStudios::Matchers::Core
     end
 
     # (see BaseMatcher#failure_message)
-    def failure_message
+    def failure_message # rubocop:disable Style/TrivialAccessors
       @failure_message
     end
 
     # (see BaseMatcher#failure_message_when_negated)
-    def failure_message_when_negated
+    def failure_message_when_negated # rubocop:disable Style/TrivialAccessors
       @failure_message_when_negated
     end
 
@@ -65,11 +67,11 @@ module RSpec::SleepingKingStudios::Matchers::Core
     #   value is compared based on the type of the expected value.
     # - Otherwise, the two objects are compared using an equality comparison.
     #
-    # @param [Object] actual The object to check.
+    # @param [Object] actual the object to check.
     #
     # @return [Boolean] true if the actual object matches the expectation,
     #   otherwise false.
-    def matches?(actual)
+    def matches?(actual) # rubocop:disable Metrics/MethodLength
       super
 
       if matcher?(@expected)
@@ -89,11 +91,11 @@ module RSpec::SleepingKingStudios::Matchers::Core
 
     def compare_arrays(expected, actual)
       compare_hashes({ _ary: expected }, { _ary: actual })
-        .map { |(char, path, *values)| [char, path[1..-1], *values] }
+        .map { |(char, path, *values)| [char, path[1..], *values] }
     end
 
     def compare_hashes(expected, actual)
-      HashDiff.diff(expected, actual, array_path: true, use_lcs: false) \
+      Hashdiff.diff(expected, actual, array_path: true, use_lcs: false) \
       do |path, exp, act|
         # Handle missing keys with matcher values.
         next nil unless nested_key?(actual, path)
@@ -135,7 +137,8 @@ module RSpec::SleepingKingStudios::Matchers::Core
       @matches = diff.empty?
 
       @failure_message_when_negated =
-        "`expect(#{format_expected(@expected)}).not_to be == #{actual.inspect}`"
+        "`expect(#{format_expected(@expected)}).not_to be == " \
+        "#{format_expected(@actual)}`"
     end
 
     def diff_hashes
@@ -150,7 +153,8 @@ module RSpec::SleepingKingStudios::Matchers::Core
       @matches = diff.empty?
 
       @failure_message_when_negated =
-        "`expect(#{format_expected(@expected)}).not_to be == #{actual.inspect}`"
+        "`expect(#{format_expected(@expected)}).not_to be == " \
+        "#{format_expected(@actual)}`"
     end
 
     def equality_matcher
@@ -159,7 +163,7 @@ module RSpec::SleepingKingStudios::Matchers::Core
 
     def format_diff(diff)
       diff
-        .sort_by { |(char, path, *_values)| [path.map(&:to_s)] }
+        .sort_by { |(_char, path, *_values)| [path.map(&:to_s)] }
         .map { |item| format_diff_item(*item) }
         .join "\n"
     end
@@ -177,9 +181,10 @@ module RSpec::SleepingKingStudios::Matchers::Core
       when '-'
         "expected #{format_expected(values.first)}"
       when '~'
-        "expected #{format_expected(values.first)}, got #{values.last.inspect}"
+        "expected #{format_expected(values.first)}, got " \
+        "#{format_expected(values.last)}"
       when '+'
-        "got #{values.last.inspect}"
+        "got #{format_expected(values.last)}"
       end
     end
 
@@ -189,12 +194,12 @@ module RSpec::SleepingKingStudios::Matchers::Core
 
     def format_message(diff)
       "expected: == #{format_expected(@expected)}\n" \
-      "     got:    #{@actual.inspect}\n" \
-      "\n" \
-      "(compared using HashDiff)\n" \
-      "\n" \
-      "Diff:\n" \
-      "#{format_diff(diff)}"
+        "     got:    #{format_expected(@actual)}\n" \
+        "\n" \
+        "(compared using Hashdiff)\n" \
+        "\n" \
+        "Diff:\n" \
+        "#{format_diff(diff)}"
     end
 
     def matcher?(object)

data/lib/rspec/sleeping_king_studios/sandbox.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+require 'rspec/core/sandbox'
+
+require 'rspec/sleeping_king_studios'
+
+module RSpec::SleepingKingStudios
+  # Helper for running RSpec files in isolation.
+  #
+  # Sandboxed files can be used to test enhancements to RSpec itself, such as
+  # custom matchers or shared or deferred example groups.
+  module Sandbox
+    # Value class for the result of calling a sandboxed spec file.
+    Result = Struct.new(:output, :errors, :json, :status, keyword_init: true) do
+      # @return [Array<String>] the full description for each run example.
+      def example_descriptions
+        json['examples'].map { |hsh| hsh['full_description'] }
+      end
+
+      # @return [Array<String>] the full description for each run example with
+      #   status "failed".
+      def failing_examples
+        json['examples']
+          .select { |hsh| hsh['status'] == 'failed' }
+          .map { |hsh| hsh['full_description'] }
+      end
+
+      # @return [Array<String>] the full description for each run example with
+      #   status "passed".
+      def passing_examples
+        json['examples']
+          .select { |hsh| hsh['status'] == 'passed' }
+          .map { |hsh| hsh['full_description'] }
+      end
+
+      # @return [Array<String>] the full description for each run example with
+      #   status "pending".
+      def pending_examples
+        json['examples']
+          .select { |hsh| hsh['status'] == 'pending' }
+          .map { |hsh| hsh['full_description'] }
+      end
+
+      # @return [String] the summary of the sandboxed spec run.
+      def summary
+        json['summary_line']
+      end
+    end
+
+    class << self
+      # Runs the specified spec files in a sandbox.
+      #
+      # The examples and other RSpec code in the files will *not* be added to
+      # the current RSpec process.
+      #
+      # @param files [Array<String>] the file names or patterns for the spec
+      #   files to run.
+      #
+      # @return [RSpec::SleepingKingStudios::Result] the status and output of
+      #   the spec run.
+      def run(*files) # rubocop:disable Metrics/MethodLength
+        if files.empty?
+          raise ArgumentError, 'must specify at least one file or pattern'
+        end
+
+        err    = StringIO.new
+        out    = StringIO.new
+        status = nil
+        args   = format_args(*files)
+
+        RSpec::Core::Sandbox.sandboxed do |config|
+          config.filter_run_when_matching :focus
+
+          status = RSpec::Core::Runner.run(args, err, out)
+        end
+
+        build_result(err:, out:, status:)
+      end
+
+      private
+
+      def build_result(err:, out:, status:)
+        *output, raw_json = out.string.lines
+
+        Result.new(
+          output: output.join,
+          errors: err.string,
+          json:   JSON.parse(raw_json),
+          status:
+        )
+      end
+
+      def format_args(*files)
+        [
+          '--format=json',
+          '--format=doc',
+          '--order=defined',
+          "--pattern=#{files.join(',')}"
+        ]
+      end
+    end
+  end
+end

data/lib/rspec/sleeping_king_studios/version.rb

@@ -11,13 +11,13 @@ module RSpec
       # Major version.
       MAJOR = 2
       # Minor version.
-      MINOR = 7
+      MINOR = 8
       # Patch version.
       PATCH = 0
       # Prerelease version.
-      PRERELEASE = nil
+      PRERELEASE = :rc
       # Build metadata.
-      BUILD = nil
+      BUILD = 0
 
       class << self
         # Generates the gem version string from the Version constants.
@@ -53,6 +53,7 @@ module RSpec
       end
     end
 
+    # The current version of the gem.
     VERSION = Version.to_gem_version
   end
 end

data/lib/rspec/sleeping_king_studios.rb

@@ -1,10 +1,15 @@
-# lib/rspec/sleeping_king_studios.rb
+# frozen_string_literal: true
 
 require 'rspec/core'
 
 module RSpec
   # Hic Iacet Arthurus, Rex Quondam, Rexque Futurus.
   module SleepingKingStudios
+    autoload :Concerns, 'rspec/sleeping_king_studios/concerns'
+    autoload :Deferred, 'rspec/sleeping_king_studios/deferred'
+    autoload :Sandbox,  'rspec/sleeping_king_studios/sandbox'
+
+    # @return [String] the path to the installed gem.
     def self.gem_path
       pattern =
         /#{File::SEPARATOR}lib#{File::SEPARATOR}rspec#{File::SEPARATOR}?\z/
@@ -12,11 +17,12 @@ module RSpec
       __dir__.sub(pattern, '')
     end
 
+    # @return [String] the gem version.
     def self.version
       @version ||= RSpec::SleepingKingStudios::Version.to_gem_version
-    end # class method version
-  end # end module
-end # module
+    end
+  end
+end
 
 require 'rspec/sleeping_king_studios/configuration'
 require 'rspec/sleeping_king_studios/version'