opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,91 +0,0 @@
-RSpec::Support.require_rspec_support "method_signature_verifier"
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `respond_to`.
-      # Not intended to be instantiated directly.
-      class RespondTo < BaseMatcher
-        def initialize(*names)
-          @names = names
-          @expected_arity = nil
-        end
-
-        # @api public
-        # Specifies the number of expected arguments.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with(3).arguments
-        def with(n)
-          @expected_arity = n
-          self
-        end
-
-        # @api public
-        # No-op. Intended to be used as syntactic sugar when using `with`.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with(3).arguments
-        def argument
-          self
-        end
-        alias :arguments :argument
-
-        # @private
-        def matches?(actual)
-          find_failing_method_names(actual, :reject).empty?
-        end
-
-        # @private
-        def does_not_match?(actual)
-          find_failing_method_names(actual, :select).empty?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{@actual.inspect} to respond to #{@failing_method_names.map { |name| name.inspect }.join(', ')}#{with_arity}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message.sub(/to respond to/, 'not to respond to')
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "respond to #{pp_names}#{with_arity}"
-        end
-
-      private
-
-        def find_failing_method_names(actual, filter_method)
-          @actual = actual
-          @failing_method_names = @names.__send__(filter_method) do |name|
-            @actual.respond_to?(name) && matches_arity?(actual, name)
-          end
-        end
-
-        def matches_arity?(actual, name)
-          return true unless @expected_arity
-
-          signature = Support::MethodSignature.new(actual.method(name))
-          Support::StrictSignatureVerifier.new(signature, Array.new(@expected_arity)).valid?
-        end
-
-        def with_arity
-          return "" unless @expected_arity
-          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
-        end
-
-        def pp_names
-          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
-          @names.length == 1 ? "##{@names.first}" : @names.inspect
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `satisfy`.
-      # Not intended to be instantiated directly.
-      class Satisfy < BaseMatcher
-        def initialize(&block)
-          @block = block
-        end
-
-        # @private
-        def matches?(actual, &block)
-          @block = block if block
-          @actual = actual
-          @block.call(actual)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{@actual} to satisfy block"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{@actual} not to satisfy block"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "satisfy block"
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Base class for the `end_with` and `start_with` matchers.
-      # Not intended to be instantiated directly.
-      class StartAndEndWith < BaseMatcher
-        def initialize(*expected)
-          @actual_does_not_have_ordered_elements = false
-          @expected = expected.length == 1 ? expected.first : expected
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          super.tap do |msg|
-            if @actual_does_not_have_ordered_elements
-              msg << ", but it does not have ordered elements"
-            elsif !actual.respond_to?(:[])
-              msg << ", but it cannot be indexed using #[]"
-            end
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          return super unless Hash === expected
-          "#{name_to_sentence} #{surface_descriptions_in(expected).inspect}"
-        end
-
-      private
-
-        def match(expected, actual)
-          return false unless actual.respond_to?(:[])
-
-          begin
-            return subset_matches? if !(Struct === expected) && expected.respond_to?(:length)
-            element_matches?
-          rescue ArgumentError
-            @actual_does_not_have_ordered_elements = true
-            return false
-          end
-        end
-
-        def actual_is_unordered
-          ArgumentError.new("#{actual.inspect} does not have ordered elements")
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `start_with`.
-      # Not intended to be instantiated directly.
-      class StartWith < StartAndEndWith
-      private
-
-        def subset_matches?
-          values_match?(expected, actual[0, expected.length])
-        end
-
-        def element_matches?
-          values_match?(expected, actual[0])
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `end_with`.
-      # Not intended to be instantiated directly.
-      class EndWith < StartAndEndWith
-      private
-
-        def subset_matches?
-          values_match?(expected, actual[-expected.length, expected.length])
-        end
-
-        def element_matches?
-          values_match?(expected, actual[-1])
-        end
-      end
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `throw_symbol`.
-      # Not intended to be instantiated directly.
-      class ThrowSymbol
-        include Composable
-
-        def initialize(expected_symbol=nil, expected_arg=nil)
-          @expected_symbol = expected_symbol
-          @expected_arg = expected_arg
-          @caught_symbol = @caught_arg = nil
-        end
-
-        # rubocop:disable MethodLength
-        # @private
-        def matches?(given_proc)
-          @block = given_proc
-          return false unless Proc === given_proc
-
-          begin
-            if @expected_symbol.nil?
-              given_proc.call
-            else
-              @caught_arg = catch :proc_did_not_throw_anything do
-                catch @expected_symbol do
-                  given_proc.call
-                  throw :proc_did_not_throw_anything, :nothing_thrown
-                end
-              end
-
-              if @caught_arg == :nothing_thrown
-                @caught_arg = nil
-              else
-                @caught_symbol = @expected_symbol
-              end
-            end
-
-            # Ruby 1.8 uses NameError with `symbol'
-            # Ruby 1.9 uses ArgumentError with :symbol
-          rescue NameError, ArgumentError => e
-            unless (match_data = e.message.match(/uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/))
-              other_exception = e
-              raise
-            end
-            @caught_symbol = match_data.captures[1].to_sym
-          rescue => other_exception
-            raise
-          ensure
-            # rubocop:disable EnsureReturn
-            unless other_exception
-              if @expected_symbol.nil?
-                return !!@caught_symbol
-              else
-                if @expected_arg.nil?
-                  return @caught_symbol == @expected_symbol
-                else
-                  return (@caught_symbol == @expected_symbol) && values_match?(@expected_arg, @caught_arg)
-                end
-              end
-            end
-            # rubocop:enable EnsureReturn
-          end
-        end
-        # rubocop:enable MethodLength
-
-        def does_not_match?(given_proc)
-          !matches?(given_proc) && Proc === given_proc
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{expected} to be thrown, #{actual_result}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, #{actual_result}"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "throw #{expected}"
-        end
-
-        # @api private
-        # Indicates this matcher matches against a block.
-        # @return [True]
-        def supports_block_expectations?
-          true
-        end
-
-        def expects_call_stack_jump?
-          true
-        end
-
-      private
-
-        def actual_result
-          return "but was not a block" unless Proc === @block
-          "got #{caught}"
-        end
-
-        def expected(symbol_desc='a Symbol')
-          throw_description(@expected_symbol || symbol_desc, @expected_arg)
-        end
-
-        def caught
-          throw_description(@caught_symbol || 'nothing', @caught_arg)
-        end
-
-        def throw_description(symbol, arg)
-          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
-
-          arg_description = if arg
-                              " with #{description_of arg}"
-                            elsif @expected_arg && @caught_symbol == @expected_symbol
-                              " with no argument"
-                            else
-                              ""
-                            end
-
-          symbol_description + arg_description
-        end
-      end
-    end
-  end
-end

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

@@ -1,420 +0,0 @@
-RSpec::Support.require_rspec_support "method_signature_verifier"
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @private
-      # Object that is yielded to `expect` when one of the
-      # yield matchers is used. Provides information about
-      # the yield behavior of the object-under-test.
-      class YieldProbe
-        def self.probe(block)
-          probe = new(block)
-          return probe unless probe.has_block?
-          probe.assert_valid_expect_block!
-          block.call(probe)
-          probe.assert_used!
-          probe
-        end
-
-        attr_accessor :num_yields, :yielded_args
-
-        def initialize(block)
-          @block = block
-          @used = false
-          self.num_yields, self.yielded_args = 0, []
-        end
-
-        def has_block?
-          Proc === @block
-        end
-
-        def to_proc
-          @used = true
-
-          probe = self
-          Proc.new do |*args|
-            probe.num_yields += 1
-            probe.yielded_args << args
-            nil # to indicate the block does not return a meaningful value
-          end
-        end
-
-        def single_yield_args
-          yielded_args.first
-        end
-
-        def yielded_once?(matcher_name)
-          case num_yields
-          when 1 then true
-          when 0 then false
-          else
-            raise "The #{matcher_name} matcher is not designed to be used with a " \
-                  "method that yields multiple times. Use the yield_successive_args " \
-                  "matcher for that case."
-          end
-        end
-
-        def successive_yield_args
-          yielded_args.map do |arg_array|
-            arg_array.size == 1 ? arg_array.first : arg_array
-          end
-        end
-
-        def assert_used!
-          return if @used
-          raise "You must pass the argument yielded to your expect block on " \
-                "to the method-under-test as a block. It acts as a probe that " \
-                "allows the matcher to detect whether or not the method-under-test " \
-                "yields, and, if so, how many times, and what the yielded arguments " \
-                "are."
-        end
-
-        if RUBY_VERSION.to_f > 1.8
-          def assert_valid_expect_block!
-            block_signature = RSpec::Support::BlockSignature.new(@block)
-            return if RSpec::Support::StrictSignatureVerifier.new(block_signature, [self]).valid?
-            raise "Your expect block must accept an argument to be used with this " \
-                  "matcher. Pass the argument as a block on to the method you are testing."
-          end
-        else
-          # On 1.8.7, `lambda { }.arity` and `lambda { |*a| }.arity` both return -1,
-          # so we can't distinguish between accepting no args and an arg splat.
-          # It's OK to skip, this, though; it just provides a nice error message
-          # when the user forgets to accept an arg in their block. They'll still get
-          # the `assert_used!` error message from above, which is sufficient.
-          def assert_valid_expect_block!
-            # nothing to do
-          end
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `yield_control`.
-      # Not intended to be instantiated directly.
-      class YieldControl < BaseMatcher
-        def initialize
-          @expectation_type = nil
-          @expected_yields_count = nil
-        end
-
-        # @api public
-        # Specifies that the method is expected to yield once.
-        def once
-          exactly(1)
-          self
-        end
-
-        # @api public
-        # Specifies that the method is expected to yield twice.
-        def twice
-          exactly(2)
-          self
-        end
-
-        # @api public
-        # Specifies that the method is expected to yield thrice.
-        def thrice
-          exactly(3)
-          self
-        end
-
-        # @api public
-        # Specifies that the method is expected to yield the given number of times.
-        def exactly(number)
-          set_expected_yields_count(:==, number)
-          self
-        end
-
-        # @api public
-        # Specifies the maximum number of times the method is expected to yield
-        def at_most(number)
-          set_expected_yields_count(:<=, number)
-          self
-        end
-
-        # @api public
-        # Specifies the minimum number of times the method is expected to yield
-        def at_least(number)
-          set_expected_yields_count(:>=, number)
-          self
-        end
-
-        # @api public
-        # No-op. Provides syntactic sugar.
-        def times
-          self
-        end
-
-        # @private
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          return false unless @probe.has_block?
-
-          if @expectation_type
-            @probe.num_yields.__send__(@expectation_type, @expected_yields_count)
-          else
-            @probe.yielded_once?(:yield_control)
-          end
-        end
-
-        # @private
-        def does_not_match?(block)
-          !matches?(block) && @probe.has_block?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          'expected given block to yield control' + failure_reason
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          'expected given block not to yield control' + failure_reason
-        end
-
-        # @private
-        def supports_block_expectations?
-          true
-        end
-
-      private
-
-        def set_expected_yields_count(relativity, n)
-          @expectation_type = relativity
-          @expected_yields_count = case n
-                                   when Numeric then n
-                                   when :once then 1
-                                   when :twice then 2
-                                   when :thrice then 3
-                                   end
-        end
-
-        def failure_reason
-          return " but was not a block" unless @probe.has_block?
-          return '' unless @expected_yields_count
-          " #{human_readable_expecation_type}#{human_readable_count}"
-        end
-
-        def human_readable_expecation_type
-          case @expectation_type
-          when :<= then 'at most '
-          when :>= then 'at least '
-          else ''
-          end
-        end
-
-        def human_readable_count
-          case @expected_yields_count
-          when 1 then "once"
-          when 2 then "twice"
-          else "#{@expected_yields_count} times"
-          end
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `yield_with_no_args`.
-      # Not intended to be instantiated directly.
-      class YieldWithNoArgs < BaseMatcher
-        # @private
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          return false unless @probe.has_block?
-          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
-        end
-
-        # @private
-        def does_not_match?(block)
-          !matches?(block) && @probe.has_block?
-        end
-
-        # @private
-        def failure_message
-          "expected given block to yield with no arguments, but #{positive_failure_reason}"
-        end
-
-        # @private
-        def failure_message_when_negated
-          "expected given block not to yield with no arguments, but #{negative_failure_reason}"
-        end
-
-        # @private
-        def supports_block_expectations?
-          true
-        end
-
-      private
-
-        def positive_failure_reason
-          return "was not a block" unless @probe.has_block?
-          return "did not yield" if @probe.num_yields.zero?
-          "yielded with arguments: #{@probe.single_yield_args.inspect}"
-        end
-
-        def negative_failure_reason
-          return "was not a block" unless @probe.has_block?
-          "did"
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `yield_with_args`.
-      # Not intended to be instantiated directly.
-      class YieldWithArgs < BaseMatcher
-        def initialize(*args)
-          @expected = args
-        end
-
-        # @private
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          return false unless @probe.has_block?
-          @actual = @probe.single_yield_args
-          @probe.yielded_once?(:yield_with_args) && args_match?
-        end
-
-        # @private
-        def does_not_match?(block)
-          !matches?(block) && @probe.has_block?
-        end
-
-        # @private
-        def failure_message
-          "expected given block to yield with arguments, but #{positive_failure_reason}"
-        end
-
-        # @private
-        def failure_message_when_negated
-          "expected given block not to yield with arguments, but #{negative_failure_reason}"
-        end
-
-        # @private
-        def description
-          desc = "yield with args"
-          desc << "(#{expected_arg_description})" unless @expected.empty?
-          desc
-        end
-
-        # @private
-        def supports_block_expectations?
-          true
-        end
-
-      private
-
-        def positive_failure_reason
-          return "was not a block" unless @probe.has_block?
-          return "did not yield" if @probe.num_yields.zero?
-          @positive_args_failure
-        end
-
-        def expected_arg_description
-          @expected.map { |e| description_of e }.join(", ")
-        end
-
-        def negative_failure_reason
-          if !@probe.has_block?
-            "was not a block"
-          elsif all_args_match?
-            "yielded with expected arguments" \
-              "\nexpected not: #{surface_descriptions_in(@expected).inspect}" +
-              "\n         got: #{@actual.inspect}"
-          else
-            "did"
-          end
-        end
-
-        def args_match?
-          if @expected.empty? # expect {...}.to yield_with_args
-            @positive_args_failure = "yielded with no arguments" if @actual.empty?
-            return !@actual.empty?
-          end
-
-          unless (match = all_args_match?)
-            @positive_args_failure = "yielded with unexpected arguments" \
-              "\nexpected: #{surface_descriptions_in(@expected).inspect}" +
-              "\n     got: #{@actual.inspect}"
-          end
-
-          match
-        end
-
-        def all_args_match?
-          values_match?(@expected, @actual)
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `yield_successive_args`.
-      # Not intended to be instantiated directly.
-      class YieldSuccessiveArgs < BaseMatcher
-        def initialize(*args)
-          @expected = args
-        end
-
-        # @private
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          return false unless @probe.has_block?
-          @actual = @probe.successive_yield_args
-          args_match?
-        end
-
-        def does_not_match?(block)
-          !matches?(block) && @probe.has_block?
-        end
-
-        # @private
-        def failure_message
-          "expected given block to yield successively with arguments, but #{positive_failure_reason}"
-        end
-
-        # @private
-        def failure_message_when_negated
-          "expected given block not to yield successively with arguments, but #{negative_failure_reason}"
-        end
-
-        # @private
-        def description
-          desc = "yield successive args"
-          desc << "(#{expected_arg_description})"
-          desc
-        end
-
-        # @private
-        def supports_block_expectations?
-          true
-        end
-
-      private
-
-        def args_match?
-          values_match?(@expected, @actual)
-        end
-
-        def expected_arg_description
-          @expected.map { |e| description_of e }.join(", ")
-        end
-
-        def positive_failure_reason
-          return "was not a block" unless @probe.has_block?
-
-          "yielded with unexpected arguments" \
-          "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
-          "\n     got: #{@actual.inspect}"
-        end
-
-        def negative_failure_reason
-          return "was not a block" unless @probe.has_block?
-
-          "yielded with expected arguments" \
-          "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
-          "\n         got: #{@actual.inspect}"
-        end
-      end
-    end
-  end
-end