opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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

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

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

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