rspec-expectations 3.8.6

data/lib/rspec/matchers/built_in/exist.rb

@@ -0,0 +1,90 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `exist`.
+      # Not intended to be instantiated directly.
+      class Exist < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          @actual = actual
+          @test = ExistenceTest.new @actual, @expected
+          @test.valid_test? && @test.actual_exists?
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          @actual = actual
+          @test = ExistenceTest.new @actual, @expected
+          @test.valid_test? && !@test.actual_exists?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to exist#{@test.validity_message}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} not to exist#{@test.validity_message}"
+        end
+
+        # @api private
+        # Simple class for memoizing actual/expected for this matcher
+        # and examining the match
+        class ExistenceTest < Struct.new(:actual, :expected)
+          # @api private
+          # @return [Boolean]
+          def valid_test?
+            uniq_truthy_values.size == 1
+          end
+
+          # @api private
+          # @return [Boolean]
+          def actual_exists?
+            existence_values.first
+          end
+
+          # @api private
+          # @return [String]
+          def validity_message
+            case uniq_truthy_values.size
+            when 0
+              " but it does not respond to either `exist?` or `exists?`"
+            when 2
+              " but `exist?` and `exists?` returned different values:\n\n"\
+              " exist?: #{existence_values.first}\n"\
+              "exists?: #{existence_values.last}"
+            end
+          end
+
+        private
+
+          def uniq_truthy_values
+            @uniq_truthy_values ||= existence_values.map { |v| !!v }.uniq
+          end
+
+          def existence_values
+            @existence_values ||= predicates.map { |p| actual.__send__(p, *expected) }
+          end
+
+          def predicates
+            @predicates ||= [:exist?, :exists?].select { |p| actual.respond_to?(p) && !deprecated(p, actual) }
+          end
+
+          def deprecated(predicate, actual)
+            predicate == :exists? && File == actual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/has.rb

@@ -0,0 +1,103 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `has_<predicate>`.
+      # Not intended to be instantiated directly.
+      class Has < BaseMatcher
+        def initialize(method_name, *args, &block)
+          @method_name, @args, @block = method_name, args, block
+        end
+
+        # @private
+        def matches?(actual, &block)
+          @actual = actual
+          @block ||= block
+          predicate_accessible? && predicate_matches?
+        end
+
+        # @private
+        def does_not_match?(actual, &block)
+          @actual = actual
+          @block ||= block
+          predicate_accessible? && !predicate_matches?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          validity_message || "expected ##{predicate}#{failure_message_args_description} to return true, got false"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          validity_message || "expected ##{predicate}#{failure_message_args_description} to return false, got true"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          [method_description, args_description].compact.join(' ')
+        end
+
+      private
+
+        def predicate_accessible?
+          !private_predicate? && predicate_exists?
+        end
+
+        # support 1.8.7, evaluate once at load time for performance
+        if String === methods.first
+          # :nocov:
+          def private_predicate?
+            @actual.private_methods.include? predicate.to_s
+          end
+          # :nocov:
+        else
+          def private_predicate?
+            @actual.private_methods.include? predicate
+          end
+        end
+
+        def predicate_exists?
+          @actual.respond_to? predicate
+        end
+
+        def predicate_matches?
+          @actual.__send__(predicate, *@args, &@block)
+        end
+
+        def predicate
+          # On 1.9, there appears to be a bug where String#match can return `false`
+          # rather than the match data object. Changing to Regex#match appears to
+          # work around this bug. For an example of this bug, see:
+          # https://travis-ci.org/rspec/rspec-expectations/jobs/27549635
+          @predicate ||= :"has_#{Matchers::HAS_REGEX.match(@method_name.to_s).captures.first}?"
+        end
+
+        def method_description
+          @method_name.to_s.tr('_', ' ')
+        end
+
+        def args_description
+          return nil if @args.empty?
+          @args.map { |arg| RSpec::Support::ObjectFormatter.format(arg) }.join(', ')
+        end
+
+        def failure_message_args_description
+          desc = args_description
+          "(#{desc})" if desc
+        end
+
+        def validity_message
+          if private_predicate?
+            "expected #{@actual} to respond to `#{predicate}` but `#{predicate}` is a private method"
+          elsif !predicate_exists?
+            "expected #{@actual} to respond to `#{predicate}`"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/have_attributes.rb

@@ -0,0 +1,114 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `have_attributes`.
+      # Not intended to be instantiated directly.
+      class HaveAttributes < BaseMatcher
+        # @private
+        attr_reader :respond_to_failed
+
+        def initialize(expected)
+          @expected = expected
+          @values = {}
+          @respond_to_failed = false
+          @negated = false
+        end
+
+        # @private
+        def actual
+          @values
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          @actual = actual
+          @negated = false
+          return false unless respond_to_attributes?
+          perform_match(:all?)
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          @actual = actual
+          @negated = true
+          return false unless respond_to_attributes?
+          perform_match(:none?)
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          described_items = surface_descriptions_in(expected)
+          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !@respond_to_failed && !@negated
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          respond_to_failure_message_or do
+            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
+          end
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
+        end
+
+      private
+
+        def cache_all_values
+          @values = {}
+          expected.each do |attribute_key, _attribute_value|
+            actual_value = @actual.__send__(attribute_key)
+            @values[attribute_key] = actual_value
+          end
+        end
+
+        def perform_match(predicate)
+          cache_all_values
+          expected.__send__(predicate) do |attribute_key, attribute_value|
+            actual_has_attribute?(attribute_key, attribute_value)
+          end
+        end
+
+        def actual_has_attribute?(attribute_key, attribute_value)
+          values_match?(attribute_value, @values.fetch(attribute_key))
+        end
+
+        def respond_to_attributes?
+          matches = respond_to_matcher.matches?(@actual)
+          @respond_to_failed = !matches
+          matches
+        end
+
+        def respond_to_matcher
+          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments
+        end
+
+        def respond_to_failure_message_or
+          if respond_to_failed
+            respond_to_matcher.failure_message
+          else
+            improve_hash_formatting(yield)
+          end
+        end
+
+        def formatted_values
+          values = RSpec::Support::ObjectFormatter.format(@values)
+          improve_hash_formatting(values)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/include.rb

@@ -0,0 +1,149 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `include`.
+      # Not intended to be instantiated directly.
+      class Include < BaseMatcher
+        # @private
+        attr_reader :expecteds
+
+        def initialize(*expecteds)
+          @expecteds = expecteds
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          actual = actual.to_hash if convert_to_hash?(actual)
+          perform_match(actual) { |v| v }
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          actual = actual.to_hash if convert_to_hash?(actual)
+          perform_match(actual) { |v| !v }
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          improve_hash_formatting("include#{readable_list_of(expecteds)}")
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          format_failure_message("to") { super }
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          format_failure_message("not to") { super }
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !diff_would_wrongly_highlight_matched_item?
+        end
+
+        # @api private
+        # @return [Array, Hash]
+        def expected
+          if expecteds.one? && Hash === expecteds.first
+            expecteds.first
+          else
+            expecteds
+          end
+        end
+
+      private
+
+        def format_failure_message(preposition)
+          if actual.respond_to?(:include?)
+            improve_hash_formatting("expected #{description_of @actual} #{preposition} include#{readable_list_of @divergent_items}")
+          else
+            improve_hash_formatting(yield) + ", but it does not respond to `include?`"
+          end
+        end
+
+        def readable_list_of(items)
+          described_items = surface_descriptions_in(items)
+          if described_items.all? { |item| item.is_a?(Hash) }
+            " #{described_items.inject(:merge).inspect}"
+          else
+            EnglishPhrasing.list(described_items)
+          end
+        end
+
+        def perform_match(actual, &block)
+          @actual = actual
+          @divergent_items = excluded_from_actual(&block)
+          actual.respond_to?(:include?) && @divergent_items.empty?
+        end
+
+        def excluded_from_actual
+          return [] unless @actual.respond_to?(:include?)
+
+          expecteds.inject([]) do |memo, expected_item|
+            if comparing_hash_to_a_subset?(expected_item)
+              expected_item.each do |(key, value)|
+                memo << { key => value } unless yield actual_hash_includes?(key, value)
+              end
+            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
+            memo
+          end
+        end
+
+        def comparing_hash_to_a_subset?(expected_item)
+          actual.is_a?(Hash) && expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_includes?(expected_key, expected_value)
+          actual_value = actual.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+
+        def comparing_hash_keys?(expected_item)
+          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_has_key?(expected_key)
+          # We check `key?` first for perf:
+          # `key?` is O(1), but `any?` is O(N).
+          actual.key?(expected_key) ||
+          actual.keys.any? { |key| values_match?(expected_key, key) }
+        end
+
+        def actual_collection_includes?(expected_item)
+          return true if actual.include?(expected_item)
+
+          # String lacks an `any?` method...
+          return false unless actual.respond_to?(:any?)
+
+          actual.any? { |value| values_match?(expected_item, value) }
+        end
+
+        def diff_would_wrongly_highlight_matched_item?
+          return false unless actual.is_a?(String) && expected.is_a?(Array)
+
+          lines = actual.split("\n")
+          expected.any? do |str|
+            actual.include?(str) && lines.none? { |line| line == str }
+          end
+        end
+
+        def convert_to_hash?(obj)
+          !obj.respond_to?(:include?) && obj.respond_to?(:to_hash)
+        end
+      end
+    end
+  end
+end