opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

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

@@ -1,4 +1,6 @@
-RSpec::Support.require_rspec_support "method_signature_verifier"
+require 'rspec/matchers/built_in/count_expectation'
+
+RSpec::Support.require_rspec_support 'method_signature_verifier'
 
 module RSpec
   module Matchers
@@ -8,34 +10,42 @@ module RSpec
       # yield matchers is used. Provides information about
       # the yield behavior of the object-under-test.
       class YieldProbe
-        def self.probe(block)
-          probe = new(block)
+        def self.probe(block, &callback)
+          probe = new(block, &callback)
           return probe unless probe.has_block?
-          probe.assert_valid_expect_block!
-          block.call(probe)
-          probe.assert_used!
-          probe
+          probe.probe
         end
 
         attr_accessor :num_yields, :yielded_args
 
-        def initialize(block)
+        def initialize(block, &callback)
           @block = block
+          @callback = callback || Proc.new {}
           @used = false
-          self.num_yields, self.yielded_args = 0, []
+          self.num_yields = 0
+          self.yielded_args = []
         end
 
         def has_block?
           Proc === @block
         end
 
+        def probe
+          assert_valid_expect_block!
+          @block.call(self)
+          assert_used!
+          self
+        end
+
         def to_proc
           @used = true
 
           probe = self
+          callback = @callback
           Proc.new do |*args|
             probe.num_yields += 1
             probe.yielded_args << args
+            callback.call(*args)
             nil # to indicate the block does not return a meaningful value
           end
         end
@@ -50,34 +60,29 @@ module RSpec
           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
+                  'method that yields multiple times. Use the yield_successive_args ' \
+                  'matcher for that case.'
           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."
+          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."
+            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
+          # :nocov:
           # 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
@@ -86,6 +91,7 @@ module RSpec
           def assert_valid_expect_block!
             # nothing to do
           end
+          # :nocov:
         end
       end
 
@@ -93,69 +99,12 @@ module RSpec
       # 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
-
+        include CountExpectation
         # @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
+          expected_count_matches?(@probe.num_yields)
         end
 
         # @private
@@ -180,38 +129,17 @@ module RSpec
           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}"
+        # @private
+        def supports_value_expectations?
+          false
         end
 
-        def human_readable_expecation_type
-          case @expectation_type
-          when :<= then 'at most '
-          when :>= then 'at least '
-          else ''
-          end
-        end
+      private
 
-        def human_readable_count
-          case @expected_yields_count
-          when 1 then "once"
-          when 2 then "twice"
-          else "#{@expected_yields_count} times"
-          end
+        def failure_reason
+          return ' but was not a block' unless @probe.has_block?
+          return "#{count_expectation_description} but did not yield" if @probe.num_yields == 0
+          count_failure_reason('yielded')
         end
       end
 
@@ -246,17 +174,22 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        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}"
+          return 'was not a block' unless @probe.has_block?
+          return 'did not yield' if @probe.num_yields.zero?
+          "yielded with arguments: #{description_of @probe.single_yield_args}"
         end
 
         def negative_failure_reason
-          return "was not a block" unless @probe.has_block?
-          "did"
+          return 'was not a block' unless @probe.has_block?
+          'did'
         end
       end
 
@@ -270,10 +203,15 @@ module RSpec
 
         # @private
         def matches?(block)
-          @probe = YieldProbe.probe(block)
+          @args_matched_when_yielded = true
+          @probe = YieldProbe.new(block) do
+            @actual = @probe.single_yield_args
+            @actual_formatted = actual_formatted
+            @args_matched_when_yielded &&= args_currently_match?
+          end
           return false unless @probe.has_block?
-          @actual = @probe.single_yield_args
-          @probe.yielded_once?(:yield_with_args) && args_match?
+          @probe.probe
+          @probe.yielded_once?(:yield_with_args) && @args_matched_when_yielded
         end
 
         # @private
@@ -293,8 +231,8 @@ module RSpec
 
         # @private
         def description
-          desc = "yield with args"
-          desc << "(#{expected_arg_description})" unless @expected.empty?
+          desc = 'yield with args'
+          desc = "#{desc}(#{expected_arg_description})" unless @expected.empty?
           desc
         end
 
@@ -303,40 +241,45 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def positive_failure_reason
-          return "was not a block" unless @probe.has_block?
-          return "did not yield" if @probe.num_yields.zero?
+          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(", ")
+          @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}"
+            'was not a block'
+          elsif @args_matched_when_yielded && !@expected.empty?
+            'yielded with expected arguments' \
+              "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
+              "\n         got: #{@actual_formatted}"
           else
-            "did"
+            'did'
           end
         end
 
-        def args_match?
+        def args_currently_match?
           if @expected.empty? # expect {...}.to yield_with_args
-            @positive_args_failure = "yielded with no arguments" if @actual.empty?
+            @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}"
+            @positive_args_failure = 'yielded with unexpected arguments' \
+              "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
+              "\n     got: #{@actual_formatted}"
           end
 
           match
@@ -357,10 +300,21 @@ module RSpec
 
         # @private
         def matches?(block)
-          @probe = YieldProbe.probe(block)
+          @actual_formatted = []
+          @actual = []
+          args_matched_when_yielded = true
+          yield_count = 0
+
+          @probe = YieldProbe.probe(block) do |*arg_array|
+            arg_or_args = arg_array.size == 1 ? arg_array.first : arg_array
+            @actual_formatted << RSpec::Support::ObjectFormatter.format(arg_or_args)
+            @actual << arg_or_args
+            args_matched_when_yielded &&= values_match?(@expected[yield_count], arg_or_args)
+            yield_count += 1
+          end
+
           return false unless @probe.has_block?
-          @actual = @probe.successive_yield_args
-          args_match?
+          args_matched_when_yielded && yield_count == @expected.length
         end
 
         def does_not_match?(block)
@@ -369,19 +323,19 @@ module RSpec
 
         # @private
         def failure_message
-          "expected given block to yield successively with arguments, but #{positive_failure_reason}"
+          '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}"
+          '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
+          "yield successive args(#{expected_arg_description})"
         end
 
         # @private
@@ -389,30 +343,31 @@ module RSpec
           true
         end
 
-      private
-
-        def args_match?
-          values_match?(@expected, @actual)
+        # @private
+        def supports_value_expectations?
+          false
         end
 
+      private
+
         def expected_arg_description
-          @expected.map { |e| description_of e }.join(", ")
+          @expected.map { |e| description_of e }.join(', ')
         end
 
         def positive_failure_reason
-          return "was not a block" unless @probe.has_block?
+          return 'was not a block' unless @probe.has_block?
 
-          "yielded with unexpected arguments" \
+          'yielded with unexpected arguments' \
           "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
-          "\n     got: #{@actual.inspect}"
+          "\n     got: [#{@actual_formatted.join(", ")}]"
         end
 
         def negative_failure_reason
-          return "was not a block" unless @probe.has_block?
+          return 'was not a block' unless @probe.has_block?
 
-          "yielded with expected arguments" \
+          'yielded with expected arguments' \
           "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
-          "\n         got: #{@actual.inspect}"
+          "\n         got: [#{@actual_formatted.join(", ")}]"
         end
       end
     end

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

@@ -16,15 +16,16 @@ module RSpec
       autoload :Be,                      'rspec/matchers/built_in/be'
       autoload :BeComparedTo,            'rspec/matchers/built_in/be'
       autoload :BeFalsey,                'rspec/matchers/built_in/be'
+      autoload :BeHelpers,               'rspec/matchers/built_in/be'
       autoload :BeNil,                   'rspec/matchers/built_in/be'
-      autoload :BePredicate,             'rspec/matchers/built_in/be'
+      autoload :BePredicate,             'rspec/matchers/built_in/has'
       autoload :BeTruthy,                'rspec/matchers/built_in/be'
       autoload :BeWithin,                'rspec/matchers/built_in/be_within'
       autoload :Change,                  'rspec/matchers/built_in/change'
       autoload :Compound,                'rspec/matchers/built_in/compound'
       autoload :ContainExactly,          'rspec/matchers/built_in/contain_exactly'
       autoload :Cover,                   'rspec/matchers/built_in/cover'
-      autoload :EndWith,                 'rspec/matchers/built_in/start_and_end_with'
+      autoload :EndWith,                 'rspec/matchers/built_in/start_or_end_with'
       autoload :Eq,                      'rspec/matchers/built_in/eq'
       autoload :Eql,                     'rspec/matchers/built_in/eql'
       autoload :Equal,                   'rspec/matchers/built_in/equal'
@@ -41,7 +42,7 @@ module RSpec
       autoload :RaiseError,              'rspec/matchers/built_in/raise_error'
       autoload :RespondTo,               'rspec/matchers/built_in/respond_to'
       autoload :Satisfy,                 'rspec/matchers/built_in/satisfy'
-      autoload :StartWith,               'rspec/matchers/built_in/start_and_end_with'
+      autoload :StartWith,               'rspec/matchers/built_in/start_or_end_with'
       autoload :ThrowSymbol,             'rspec/matchers/built_in/throw_symbol'
       autoload :YieldControl,            'rspec/matchers/built_in/yield'
       autoload :YieldSuccessiveArgs,     'rspec/matchers/built_in/yield'

data/rspec-expectations/upstream/lib/rspec/matchers/composable.rb

@@ -80,8 +80,7 @@ module RSpec
       #
       # @!visibility public
       def description_of(object)
-        return object.description if Matchers.is_a_describable_matcher?(object)
-        object.inspect
+        RSpec::Support::ObjectFormatter.format(object)
       end
 
       # Transforms the given data structue (typically a hash or array)
@@ -101,14 +100,10 @@ module RSpec
           DescribableItem.new(item)
         elsif Hash === item
           Hash[surface_descriptions_in(item.to_a)]
-        elsif Struct === item
-          item.inspect
-        elsif enumerable?(item)
-          begin
-            item.map { |subitem| surface_descriptions_in(subitem) }
-          rescue IOError # STDOUT is enumerable but `map` raises an error
-            item.inspect
-          end
+        elsif Struct === item || unreadable_io?(item)
+          RSpec::Support::ObjectFormatter.format(item)
+        elsif should_enumerate?(item)
+          item.map { |subitem| surface_descriptions_in(subitem) }
         else
           item
         end
@@ -135,45 +130,38 @@ module RSpec
           object.clone
         elsif Hash === object
           Hash[with_matchers_cloned(object.to_a)]
-        elsif Struct === object
-          object
-        elsif enumerable?(object)
-          begin
-            object.map { |subobject| with_matchers_cloned(subobject) }
-          rescue IOError # STDOUT is enumerable but `map` raises an error
-            object
-          end
+        elsif should_enumerate?(object)
+          object.map { |subobject| with_matchers_cloned(subobject) }
         else
           object
         end
       end
 
-      if String.ancestors.include?(Enumerable) # 1.8.7
-        # Strings are not enumerable on 1.9, and on 1.8 they are an infinitely
-        # nested enumerable: since ruby lacks a character class, it yields
-        # 1-character strings, which are themselves enumerable, composed of a
-        # a single 1-character string, which is an enumerable, etc.
-        #
-        # @api private
-        def enumerable?(item)
-          return false if String === item
-          Enumerable === item
-        end
-      else
-        # @api private
-        def enumerable?(item)
-          Enumerable === item
-        end
+      # @api private
+      # We should enumerate arrays as long as they are not recursive.
+      def should_enumerate?(item)
+        Array === item && item.none? { |subitem| subitem.equal?(item) }
+      end
+
+      # @api private
+      def unreadable_io?(object)
+        return false unless IO === object
+        object.each {} # STDOUT is enumerable but raises an error
+        false
+      rescue IOError
+        true
       end
-      module_function :surface_descriptions_in, :enumerable?
+      module_function :surface_descriptions_in, :should_enumerate?, :unreadable_io?
 
       # Wraps an item in order to surface its `description` via `inspect`.
       # @api private
       DescribableItem = Struct.new(:item) do
+        # Inspectable version of the item description
         def inspect
           "(#{item.description})"
         end
 
+        # A pretty printed version of the item description.
         def pretty_print(pp)
           pp.text "(#{item.description})"
         end