opal-connect-rspec 0.5.0

data/rspec-expectations/lib/rspec/matchers/built_in/cover.rb

@@ -0,0 +1,24 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `cover`.
+      # Not intended to be instantiated directly.
+      class Cover < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(range)
+          @actual = range
+          @expected.all? { |e| range.cover?(e) }
+        end
+
+        def does_not_match?(range)
+          @actual = range
+          expected.none? { |e| range.cover?(e) }
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/lib/rspec/matchers/built_in/eq.rb

@@ -0,0 +1,75 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `eq`.
+      # Not intended to be instantiated directly.
+      class Eq < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          "\nexpected: #{format_object(expected)}\n     got: #{format_object(actual)}\n\n(compared using ==)\n"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "\nexpected: value != #{format_object(expected)}\n     got: #{format_object(actual)}\n\n(compared using ==)\n"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "#{name_to_sentence} #{@expected.inspect}"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+      private
+
+        def match(expected, actual)
+          actual == expected
+        end
+
+        def format_object(object)
+          if Time === object
+            format_time(object)
+          elsif defined?(DateTime) && DateTime === object
+            format_date_time(object)
+          elsif defined?(BigDecimal) && BigDecimal === object
+            "#{object.to_s 'F'} (#{object.inspect})"
+          else
+            object.inspect
+          end
+        end
+
+        TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+        if Time.method_defined?(:nsec)
+          def format_time(time)
+            time.strftime("#{TIME_FORMAT}.#{"%09d" % time.nsec} %z")
+          end
+        else # for 1.8.7
+          def format_time(time)
+            time.strftime("#{TIME_FORMAT}.#{"%06d" % time.usec} %z")
+          end
+        end
+
+        DATE_TIME_FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
+        # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
+        # defined use a custom format string that includes more time precision.
+        def format_date_time(date_time)
+          if defined?(ActiveSupport)
+            date_time.strftime(DATE_TIME_FORMAT)
+          else
+            date_time.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/lib/rspec/matchers/built_in/eql.rb

@@ -0,0 +1,34 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `eql`.
+      # Not intended to be instantiated directly.
+      class Eql < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+      private
+
+        def match(expected, actual)
+          actual.eql? expected
+        end
+      end
+    end
+  end
+end

data/rspec-expectations/lib/rspec/matchers/built_in/equal.rb

@@ -0,0 +1,81 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `equal`.
+      # Not intended to be instantiated directly.
+      class Equal < BaseMatcher
+        # @api private
+        # @return [String]
+        def failure_message
+          if expected_is_a_literal_singleton?
+            simple_failure_message
+          else
+            detailed_failure_message
+          end
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          <<-MESSAGE
+
+expected not #{inspect_object(actual)}
+         got #{inspect_object(expected)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          !expected_is_a_literal_singleton?
+        end
+
+      private
+
+        def match(expected, actual)
+          actual.equal? expected
+        end
+
+        LITERAL_SINGLETONS = [true, false, nil]
+
+        def expected_is_a_literal_singleton?
+          LITERAL_SINGLETONS.include?(expected)
+        end
+
+        def actual_inspected
+          if LITERAL_SINGLETONS.include?(actual)
+            actual.inspect
+          else
+            inspect_object(actual)
+          end
+        end
+
+        def simple_failure_message
+          "\nexpected #{expected.inspect}\n     got #{actual_inspected}\n"
+        end
+
+        def detailed_failure_message
+          <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+`expect(actual).to eq(expected)` if you don't care about
+object identity in this example.
+
+MESSAGE
+        end
+
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+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.inspect} to exist#{@test.validity_message}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{@actual.inspect} 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) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+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
+          def private_predicate?
+            @actual.private_methods.include? predicate.to_s
+          end
+        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.gsub('_', ' ')
+        end
+
+        def args_description
+          return nil if @args.empty?
+          @args.map { |arg| arg.inspect }.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/rspec-expectations/lib/rspec/matchers/built_in/have_attributes.rb

@@ -0,0 +1,84 @@
+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
+          @respond_to_failed = false
+        end
+
+        # @api private
+        # @return [Boolean]
+        def matches?(actual)
+          @actual = actual
+          return false unless respond_to_attributes?
+          perform_match(:all?)
+        end
+
+        # @api private
+        # @return [Boolean]
+        def does_not_match?(actual)
+          @actual = actual
+          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 #{described_items.inspect}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          respond_to_failure_message_or { super }
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          respond_to_failure_message_or { super }
+        end
+
+      private
+
+        def perform_match(predicate)
+          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)
+          actual_value = actual.__send__(attribute_key)
+          values_match?(attribute_value, actual_value)
+        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
+      end
+    end
+  end
+end