opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/rspec-mocks/upstream/lib/rspec/mocks/instance_method_stasher.rb

@@ -0,0 +1,135 @@
+module RSpec
+  module Mocks
+    # @private
+    class InstanceMethodStasher
+      def initialize(object, method)
+        @object = object
+        @method = method
+        @klass = (class << object; self; end)
+
+        @original_method = nil
+        @method_is_stashed = false
+      end
+
+      attr_reader :original_method
+
+      if RUBY_VERSION.to_f < 1.9
+        # @private
+        def method_is_stashed?
+          @method_is_stashed
+        end
+
+        # @private
+        def stash
+          return if !method_defined_directly_on_klass? || @method_is_stashed
+
+          @klass.__send__(:alias_method, stashed_method_name, @method)
+          @method_is_stashed = true
+        end
+
+        # @private
+        def stashed_method_name
+          "obfuscated_by_rspec_mocks__#{@method}"
+        end
+        private :stashed_method_name
+
+        # @private
+        def restore
+          return unless @method_is_stashed
+
+          if @klass.__send__(:method_defined?, @method)
+            @klass.__send__(:undef_method, @method)
+          end
+          @klass.__send__(:alias_method, @method, stashed_method_name)
+          @klass.__send__(:remove_method, stashed_method_name)
+          @method_is_stashed = false
+        end
+      else
+
+        # @private
+        def method_is_stashed?
+          !!@original_method
+        end
+
+        # @private
+        def stash
+          return unless method_defined_directly_on_klass?
+          @original_method ||= ::RSpec::Support.method_handle_for(@object, @method)
+        end
+
+        # @private
+        def restore
+          return unless @original_method
+
+          if @klass.__send__(:method_defined?, @method)
+            @klass.__send__(:undef_method, @method)
+          end
+
+          handle_restoration_failures do
+            @klass.__send__(:define_method, @method, @original_method)
+          end
+
+          @original_method = nil
+        end
+      end
+
+      if RUBY_DESCRIPTION.include?('2.0.0p247') || RUBY_DESCRIPTION.include?('2.0.0p195')
+        # ruby 2.0.0-p247 and 2.0.0-p195 both have a bug that we can't work around :(.
+        # https://bugs.ruby-lang.org/issues/8686
+        def handle_restoration_failures
+          yield
+        rescue TypeError
+          RSpec.warn_with(
+            "RSpec failed to properly restore a partial double (#{@object.inspect}) " \
+            "to its original state due to a known bug in MRI 2.0.0-p195 & p247 " \
+            "(https://bugs.ruby-lang.org/issues/8686). This object may remain " \
+            "screwed up for the rest of this process. Please upgrade to 2.0.0-p353 or above.",
+            :call_site => nil, :use_spec_location_as_call_site => true
+          )
+        end
+      else
+        def handle_restoration_failures
+          # No known reasons for restoration to fail on other rubies.
+          yield
+        end
+      end
+
+    private
+
+      # @private
+      def method_defined_directly_on_klass?
+        method_defined_on_klass? && method_owned_by_klass?
+      end
+
+      # @private
+      def method_defined_on_klass?(klass=@klass)
+        MethodReference.method_defined_at_any_visibility?(klass, @method)
+      end
+
+      def method_owned_by_klass?
+        owner = @klass.instance_method(@method).owner
+
+        # On Ruby 2.0.0+ the owner of a method on a class which has been
+        # `prepend`ed may actually be an instance, e.g.
+        # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
+        owner = owner.class unless Module === owner
+
+        # On some 1.9s (e.g. rubinius) aliased methods
+        # can report the wrong owner. Example:
+        # class MyClass
+        #   class << self
+        #     alias alternate_new new
+        #   end
+        # end
+        #
+        # MyClass.owner(:alternate_new) returns `Class` when incorrect,
+        # but we need to consider the owner to be `MyClass` because
+        # it is not actually available on `Class` but is on `MyClass`.
+        # Hence, we verify that the owner actually has the method defined.
+        # If the given owner does not have the method defined, we assume
+        # that the method is actually owned by @klass.
+        owner == @klass || !(method_defined_on_klass?(owner))
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/marshal_extension.rb

@@ -0,0 +1,41 @@
+module RSpec
+  module Mocks
+    # Support for `patch_marshal_to_support_partial_doubles` configuration.
+    #
+    # @private
+    class MarshalExtension
+      def self.patch!
+        return if Marshal.respond_to?(:dump_with_rspec_mocks)
+
+        Marshal.instance_eval do
+          class << self
+            def dump_with_rspec_mocks(object, *rest)
+              if !::RSpec::Mocks.space.registered?(object) || NilClass === object
+                dump_without_rspec_mocks(object, *rest)
+              else
+                dump_without_rspec_mocks(object.dup, *rest)
+              end
+            end
+
+            alias_method :dump_without_rspec_mocks, :dump
+            undef_method :dump
+            alias_method :dump, :dump_with_rspec_mocks
+          end
+        end
+      end
+
+      def self.unpatch!
+        return unless Marshal.respond_to?(:dump_with_rspec_mocks)
+
+        Marshal.instance_eval do
+          class << self
+            undef_method :dump_with_rspec_mocks
+            undef_method :dump
+            alias_method :dump, :dump_without_rspec_mocks
+            undef_method :dump_without_rspec_mocks
+          end
+        end
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/matchers/expectation_customization.rb

@@ -0,0 +1,20 @@
+module RSpec
+  module Mocks
+    module Matchers
+      # @private
+      class ExpectationCustomization
+        attr_accessor :block
+
+        def initialize(method_name, args, block)
+          @method_name = method_name
+          @args        = args
+          @block       = block
+        end
+
+        def playback_onto(expectation)
+          expectation.__send__(@method_name, *@args, &@block)
+        end
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/matchers/have_received.rb

@@ -0,0 +1,121 @@
+module RSpec
+  module Mocks
+    module Matchers
+      # @private
+      class HaveReceived
+        COUNT_CONSTRAINTS = %w[exactly at_least at_most times once twice thrice]
+        ARGS_CONSTRAINTS = %w[with]
+        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS + %w[ordered]
+
+        def initialize(method_name, &block)
+          @method_name = method_name
+          @block = block
+          @constraints = []
+          @subject = nil
+        end
+
+        def name
+          "have_received"
+        end
+
+        def matches?(subject, &block)
+          @block ||= block
+          @subject = subject
+          @expectation = expect
+          mock_proxy.ensure_implemented(@method_name)
+
+          expected_messages_received_in_order?
+        end
+
+        def does_not_match?(subject)
+          @subject = subject
+          ensure_count_unconstrained
+          @expectation = expect.never
+          mock_proxy.ensure_implemented(@method_name)
+          expected_messages_received_in_order?
+        end
+
+        def failure_message
+          generate_failure_message
+        end
+
+        def failure_message_when_negated
+          generate_failure_message
+        end
+
+        def description
+          expect.description
+        end
+
+        CONSTRAINTS.each do |expectation|
+          define_method expectation do |*args|
+            @constraints << [expectation, *args]
+            self
+          end
+        end
+
+        def setup_allowance(_subject, &_block)
+          disallow("allow", " as it would have no effect")
+        end
+
+        def setup_any_instance_allowance(_subject, &_block)
+          disallow("allow_any_instance_of")
+        end
+
+        def setup_any_instance_expectation(_subject, &_block)
+          disallow("expect_any_instance_of")
+        end
+
+      private
+
+        def disallow(type, reason="")
+          raise RSpec::Mocks::MockExpectationError,
+                "Using #{type}(...) with the `have_received` " \
+                "matcher is not supported#{reason}."
+        end
+
+        def expect
+          @expectation ||= begin
+            expectation = mock_proxy.build_expectation(@method_name)
+            apply_constraints_to expectation
+            expectation
+          end
+        end
+
+        def apply_constraints_to(expectation)
+          @constraints.each do |constraint|
+            expectation.send(*constraint)
+          end
+        end
+
+        def ensure_count_unconstrained
+          return unless count_constraint
+          raise RSpec::Mocks::MockExpectationError,
+                "can't use #{count_constraint} when negative"
+        end
+
+        def count_constraint
+          @constraints.map(&:first).find do |constraint|
+            COUNT_CONSTRAINTS.include?(constraint)
+          end
+        end
+
+        def generate_failure_message
+          mock_proxy.check_for_unexpected_arguments(@expectation)
+          @expectation.generate_error
+        rescue RSpec::Mocks::MockExpectationError => error
+          error.message
+        end
+
+        def expected_messages_received_in_order?
+          mock_proxy.replay_received_message_on @expectation, &@block
+          @expectation.expected_messages_received? && @expectation.ensure_expected_ordering_received!
+        end
+
+        def mock_proxy
+          RSpec::Mocks.space.proxy_for(@subject)
+        end
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/matchers/receive.rb

@@ -0,0 +1,106 @@
+RSpec::Support.require_rspec_mocks 'matchers/expectation_customization'
+
+module RSpec
+  module Mocks
+    module Matchers
+      # @private
+      class Receive
+        def initialize(message, block)
+          @message                 = message
+          @block                   = block
+          @recorded_customizations = []
+        end
+
+        def name
+          "receive"
+        end
+
+        def setup_expectation(subject, &block)
+          warn_if_any_instance("expect", subject)
+          setup_mock_proxy_method_substitute(subject, :add_message_expectation, block)
+        end
+        alias matches? setup_expectation
+
+        def setup_negative_expectation(subject, &block)
+          # ensure `never` goes first for cases like `never.and_return(5)`,
+          # where `and_return` is meant to raise an error
+          @recorded_customizations.unshift ExpectationCustomization.new(:never, [], nil)
+
+          warn_if_any_instance("expect", subject)
+
+          setup_expectation(subject, &block)
+        end
+        alias does_not_match? setup_negative_expectation
+
+        def setup_allowance(subject, &block)
+          warn_if_any_instance("allow", subject)
+          setup_mock_proxy_method_substitute(subject, :add_stub, block)
+        end
+
+        def setup_any_instance_expectation(subject, &block)
+          setup_any_instance_method_substitute(subject, :should_receive, block)
+        end
+
+        def setup_any_instance_negative_expectation(subject, &block)
+          setup_any_instance_method_substitute(subject, :should_not_receive, block)
+        end
+
+        def setup_any_instance_allowance(subject, &block)
+          setup_any_instance_method_substitute(subject, :stub, block)
+        end
+
+        MessageExpectation.public_instance_methods(false).each do |method|
+          next if method_defined?(method)
+
+          define_method(method) do |*args, &block|
+            @recorded_customizations << ExpectationCustomization.new(method, args, block)
+            self
+          end
+        end
+
+      private
+
+        def warn_if_any_instance(expression, subject)
+          return unless AnyInstance::Proxy === subject
+
+          RSpec.warning(
+            "`#{expression}(#{subject.klass}.any_instance).to` " \
+            "is probably not what you meant, it does not operate on " \
+            "any instance of `#{subject.klass}`. " \
+            "Use `#{expression}_any_instance_of(#{subject.klass}).to` instead."
+          )
+        end
+
+        def setup_mock_proxy_method_substitute(subject, method, block)
+          proxy = ::RSpec::Mocks.space.proxy_for(subject)
+          setup_method_substitute(proxy, method, block)
+        end
+
+        def setup_any_instance_method_substitute(subject, method, block)
+          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
+          setup_method_substitute(proxy, method, block)
+        end
+
+        def setup_method_substitute(host, method, block, *args)
+          args << @message.to_sym
+          block = move_block_to_last_customization(block)
+
+          expectation = host.__send__(method, *args, &(@block || block))
+
+          @recorded_customizations.each do |customization|
+            customization.playback_onto(expectation)
+          end
+          expectation
+        end
+
+        def move_block_to_last_customization(block)
+          last = @recorded_customizations.last
+          return block unless last
+
+          last.block ||= block
+          nil
+        end
+      end
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/matchers/receive_message_chain.rb

@@ -0,0 +1,66 @@
+RSpec::Support.require_rspec_mocks 'matchers/expectation_customization'
+
+module RSpec
+  module Mocks
+    module Matchers
+      # @private
+      class ReceiveMessageChain
+        def initialize(chain, &block)
+          @chain = chain
+          @block = block
+          @recorded_customizations  = []
+        end
+
+        [:with, :and_return, :and_throw, :and_raise, :and_yield, :and_call_original].each do |msg|
+          define_method(msg) do |*args, &block|
+            @recorded_customizations << ExpectationCustomization.new(msg, args, block)
+            self
+          end
+        end
+
+        def name
+          "receive_message_chain"
+        end
+
+        def setup_allowance(subject, &block)
+          chain = StubChain.stub_chain_on(subject, *@chain, &(@block || block))
+          replay_customizations(chain)
+        end
+
+        def setup_any_instance_allowance(subject, &block)
+          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
+          chain = proxy.stub_chain(*@chain, &(@block || block))
+          replay_customizations(chain)
+        end
+
+        def setup_any_instance_expectation(subject, &block)
+          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
+          chain = proxy.expect_chain(*@chain, &(@block || block))
+          replay_customizations(chain)
+        end
+
+        def setup_expectation(subject, &block)
+          chain = ExpectChain.expect_chain_on(subject, *@chain, &(@block || block))
+          replay_customizations(chain)
+        end
+
+        def setup_negative_expectation(*_args)
+          raise NegationUnsupportedError,
+                "`expect(...).not_to receive_message_chain` is not supported " \
+                "since it doesn't really make sense. What would it even mean?"
+        end
+
+        alias matches? setup_expectation
+        alias does_not_match? setup_negative_expectation
+
+      private
+
+        def replay_customizations(chain)
+          @recorded_customizations.each do |customization|
+            customization.playback_onto(chain)
+          end
+        end
+      end
+    end
+  end
+end