opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,152 @@
+require 'stringio'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `output`.
+      # Not intended to be instantiated directly.
+      class Output < BaseMatcher
+        def initialize(expected)
+          @expected        = expected
+          @actual          = ""
+          @block           = nil
+          @stream_capturer = NullCapture
+        end
+
+        def matches?(block)
+          @block = block
+          return false unless Proc === block
+          @actual = @stream_capturer.capture(block)
+          @expected ? values_match?(@expected, @actual) : captured?
+        end
+
+        def does_not_match?(block)
+          !matches?(block) && Proc === block
+        end
+
+        # @api public
+        # Tells the matcher to match against stdout.
+        def to_stdout
+          @stream_capturer = CaptureStdout
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        def to_stderr
+          @stream_capturer = CaptureStderr
+          self
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected block to #{description}, but #{positive_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected block to not #{description}, but #{negative_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          if @expected
+            "output #{description_of @expected} to #{@stream_capturer.name}"
+          else
+            "output to #{@stream_capturer.name}"
+          end
+        end
+
+        # @api private
+        # @return [Boolean]
+        def diffable?
+          true
+        end
+
+        # @api private
+        # Indicates this matcher matches against a block.
+        # @return [True]
+        def supports_block_expectations?
+          true
+        end
+
+      private
+
+        def captured?
+          @actual.length > 0
+        end
+
+        def positive_failure_reason
+          return "was not a block" unless Proc === @block
+          return "output #{actual_output_description}" if @expected
+          "did not"
+        end
+
+        def negative_failure_reason
+          return "was not a block" unless Proc === @block
+          "output #{actual_output_description}"
+        end
+
+        def actual_output_description
+          return "nothing" unless captured?
+          @actual.inspect
+        end
+      end
+
+      # @private
+      module NullCapture
+        def self.name
+          "some stream"
+        end
+
+        def self.capture(_block)
+          raise "You must chain `to_stdout` or `to_stderr` off of the `output(...)` matcher."
+        end
+      end
+
+      # @private
+      module CaptureStdout
+        def self.name
+          'stdout'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stdout
+          $stdout = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stdout = original_stream
+        end
+      end
+
+      # @private
+      module CaptureStderr
+        def self.name
+          'stderr'
+        end
+
+        def self.capture(block)
+          captured_stream = StringIO.new
+
+          original_stream = $stderr
+          $stderr = captured_stream
+
+          block.call
+
+          captured_stream.string
+        ensure
+          $stderr = original_stream
+        end
+      end
+    end
+  end
+end

data/{vendor_lib → rspec-expectations/lib}/rspec/matchers/built_in/raise_error.rb

@@ -1,7 +1,13 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `raise_error`.
+      # Not intended to be instantiated directly.
+      # rubocop:disable ClassLength
       class RaiseError
+        include Composable
+
         def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
           @block = block
           @actual_error = nil
@@ -13,28 +19,30 @@ module RSpec
           end
         end
 
+        # @api public
+        # Specifies the expected error message.
         def with_message(expected_message)
           raise_message_already_set if @expected_message
           @expected_message = expected_message
           self
         end
 
-        def matches?(given_proc, negative_expectation = false, &block)
+        # rubocop:disable MethodLength
+        # @private
+        def matches?(given_proc, negative_expectation=false, &block)
+          @given_proc = given_proc
           @block ||= block
           @raised_expected_error = false
           @with_expected_message = false
           @eval_block = false
           @eval_block_passed = false
 
-          unless given_proc.respond_to?(:call)
-            ::Kernel.warn "`raise_error` was called with non-proc object #{given_proc.inspect}"
-            return false
-          end
+          return false unless Proc === given_proc
 
           begin
             given_proc.call
           rescue Exception => @actual_error
-            if @actual_error == @expected_error || @expected_error === @actual_error
+            if values_match?(@expected_error, @actual_error)
               @raised_expected_error = true
               @with_expected_message = verify_message
             end
@@ -46,8 +54,42 @@ module RSpec
 
           expectation_matched?
         end
+        # rubocop:enable MethodLength
 
-        alias == matches?
+        # @private
+        def does_not_match?(given_proc)
+          prevent_invalid_expectations
+          !matches?(given_proc, :negative_expectation) && Proc === given_proc
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        def expects_call_stack_jump?
+          true
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "raise #{expected_error}"
+        end
+
+      private
 
         def expectation_matched?
           error_and_message_match? && block_matches?
@@ -61,11 +103,6 @@ module RSpec
           @eval_block ? @eval_block_passed : true
         end
 
-        def does_not_match?(given_proc)
-          prevent_invalid_expectations
-          !matches?(given_proc, :negative_expectation)
-        end
-
         def eval_block
           @eval_block = true
           begin
@@ -77,52 +114,33 @@ module RSpec
         end
 
         def verify_message
-          case @expected_message
-          when nil
-            true
-          when Regexp
-            @expected_message =~ @actual_error.message
-          else
-            @expected_message == @actual_error.message
-          end
-        end
-
-        def failure_message_for_should
-          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+          return true if @expected_message.nil?
+          values_match?(@expected_message, @actual_error.message)
         end
 
-        def failure_message_for_should_not
-          "expected no #{expected_error}#{given_error}"
-        end
-
-        def description
-          "raise #{expected_error}"
-        end
+        def prevent_invalid_expectations
+          what_to_raise = if expecting_specific_exception? && @expected_message
+                            "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                          elsif expecting_specific_exception?
+                            "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                          elsif @expected_message
+                            "`expect { }.not_to raise_error(message)`"
+                          end
 
-        private
+          return unless what_to_raise
 
-        def prevent_invalid_expectations
-          if (expecting_specific_exception? || @expected_message)
-            what_to_raise = if expecting_specific_exception? && @expected_message
-                                  "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
-                                elsif expecting_specific_exception?
-                                  "`expect { }.not_to raise_error(SpecificErrorClass)`"
-                                elsif @expected_message
-                                  "`expect { }.not_to raise_error(message)`"
-                                end
-            specific_class_error = ArgumentError.new("#{what_to_raise} is not valid, use `expect { }.not_to raise_error` (with no args) instead")
-            raise specific_class_error
-          end
+          specific_class_error = ArgumentError.new("#{what_to_raise} is not valid, use `expect { }.not_to raise_error` (with no args) instead")
+          raise specific_class_error
         end
 
         def expected_error
           case @expected_message
           when nil
-            @expected_error.inspect
+            description_of(@expected_error)
           when Regexp
             "#{@expected_error} with message matching #{@expected_message.inspect}"
           else
-            "#{@expected_error} with #{@expected_message.inspect}"
+            "#{@expected_error} with #{description_of @expected_message}"
           end
         end
 
@@ -132,6 +150,7 @@ module RSpec
         end
 
         def given_error
+          return " but was not given a block" unless Proc === @given_proc
           return " but nothing was raised" unless @actual_error
 
           backtrace = format_backtrace(@actual_error.backtrace)
@@ -149,6 +168,7 @@ module RSpec
           raise "`expect { }.to raise_error(message).with_message(message)` is not valid. The matcher only allows the expected message to be specified once"
         end
       end
+      # rubocop:enable ClassLength
     end
   end
 end

data/{vendor_lib → rspec-expectations/lib}/rspec/matchers/built_in/respond_to.rb

@@ -1,44 +1,66 @@
+RSpec::Support.require_rspec_support "method_signature_verifier"
+
 module RSpec
   module Matchers
     module BuiltIn
-      class RespondTo
+      # @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
-        alias == matches?
 
+        # @private
         def does_not_match?(actual)
           find_failing_method_names(actual, :select).empty?
         end
 
-        def failure_message_for_should
-          "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{@actual.inspect} to respond to #{@failing_method_names.map { |name| name.inspect }.join(', ')}#{with_arity}"
         end
 
-        def failure_message_for_should_not
-          failure_message_for_should.sub(/to respond to/, 'not to respond to')
+        # @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
 
-        def with(n)
-          @expected_arity = n
-          self
-        end
-
-        def argument
-          self
-        end
-        alias :arguments :argument
-
-        private
+      private
 
         def find_failing_method_names(actual, filter_method)
           @actual = actual
@@ -50,18 +72,13 @@ module RSpec
         def matches_arity?(actual, name)
           return true unless @expected_arity
 
-          actual_arity = actual.method(name).arity
-          if actual_arity < 0
-            # ~ inverts the one's complement and gives us the number of required args
-            ~actual_arity <= @expected_arity
-          else
-            actual_arity == @expected_arity
-          end
+          signature = Support::MethodSignature.new(actual.method(name))
+          Support::StrictSignatureVerifier.new(signature, Array.new(@expected_arity)).valid?
         end
 
         def with_arity
-          @expected_arity.nil?? "" :
-            " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+          return "" unless @expected_arity
+          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
         end
 
         def pp_names

data/{vendor_lib → rspec-expectations/lib}/rspec/matchers/built_in/satisfy.rb

@@ -1,26 +1,35 @@
 module RSpec
   module Matchers
     module BuiltIn
-      class Satisfy
+      # @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
-        alias == matches?
 
-        def failure_message_for_should
+        # @api private
+        # @return [String]
+        def failure_message
           "expected #{@actual} to satisfy block"
         end
 
-        def failure_message_for_should_not
+        # @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

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

@@ -0,0 +1,82 @@
+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/{vendor_lib → rspec-expectations/lib}/rspec/matchers/built_in/throw_symbol.rb

@@ -1,14 +1,24 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `throw_symbol`.
+      # Not intended to be instantiated directly.
       class ThrowSymbol
-        def initialize(expected_symbol = nil, expected_arg=nil)
+        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
@@ -30,44 +40,72 @@ module RSpec
             # Ruby 1.8 uses NameError with `symbol'
             # Ruby 1.9 uses ArgumentError with :symbol
           rescue NameError, ArgumentError => e
-            unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+            unless (match_data = e.message.match(/uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/))
               other_exception = e
               raise
             end
-            @caught_symbol = $2.to_sym
+            @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.nil?
+                return !!@caught_symbol
               else
                 if @expected_arg.nil?
                   return @caught_symbol == @expected_symbol
                 else
-                  return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+                  return (@caught_symbol == @expected_symbol) && values_match?(@expected_arg, @caught_arg)
                 end
               end
             end
+            # rubocop:enable EnsureReturn
           end
         end
-        alias == matches?
+        # rubocop:enable MethodLength
 
-        def failure_message_for_should
-          "expected #{expected} to be thrown, got #{caught}"
+        def does_not_match?(given_proc)
+          !matches?(given_proc) && Proc === given_proc
         end
 
-        def failure_message_for_should_not
-          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+        # @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
 
-        private
+        # @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')
+        def expected(symbol_desc='a Symbol')
           throw_description(@expected_symbol || symbol_desc, @expected_arg)
         end
 
@@ -79,7 +117,7 @@ module RSpec
           symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
 
           arg_description = if arg
-                              " with #{arg.inspect}"
+                              " with #{description_of arg}"
                             elsif @expected_arg && @caught_symbol == @expected_symbol
                               " with no argument"
                             else