opal-rspec-cj 0.4.4

data/vendor_lib/rspec/mocks/extensions/marshal.rb

@@ -0,0 +1,17 @@
+module Marshal
+  class << self
+    # Duplicates any mock objects before serialization. Otherwise,
+    # serialization will fail because methods exist on the singleton class.
+    def dump_with_mocks(object, *rest)
+      if ::RSpec::Mocks.space.nil? || !::RSpec::Mocks.space.registered?(object) || NilClass === object
+        dump_without_mocks(object, *rest)
+      else
+        dump_without_mocks(object.dup, *rest)
+      end
+    end
+
+    alias_method :dump_without_mocks, :dump
+    undef_method :dump
+    alias_method :dump, :dump_with_mocks
+  end
+end

data/vendor_lib/rspec/mocks/framework.rb

@@ -0,0 +1,36 @@
+# Require everything except the global extensions of class and object. This
+# supports wrapping rspec's mocking functionality without invading every
+# object in the system.
+
+require 'rspec/support/caller_filter'
+require 'rspec/support/warnings'
+require 'rspec/mocks/instance_method_stasher'
+require 'rspec/mocks/method_double'
+require 'rspec/mocks/argument_matchers'
+require 'rspec/mocks/example_methods'
+require 'rspec/mocks/proxy'
+require 'rspec/mocks/proxy_for_nil'
+require 'rspec/mocks/test_double'
+require 'rspec/mocks/mock'
+require 'rspec/mocks/argument_list_matcher'
+require 'rspec/mocks/message_expectation'
+require 'rspec/mocks/order_group'
+require 'rspec/mocks/errors'
+require 'rspec/mocks/error_generator'
+require 'rspec/mocks/space'
+require 'rspec/mocks/extensions/marshal'
+require 'rspec/mocks/any_instance/chain'
+require 'rspec/mocks/any_instance/stub_chain'
+require 'rspec/mocks/any_instance/stub_chain_chain'
+require 'rspec/mocks/any_instance/expectation_chain'
+require 'rspec/mocks/any_instance/message_chains'
+require 'rspec/mocks/any_instance/recorder'
+require 'rspec/mocks/mutate_const'
+require 'rspec/mocks/matchers/have_received'
+require 'rspec/mocks/matchers/receive'
+require 'rspec/mocks/matchers/receive_messages'
+require 'rspec/mocks/stub_chain'
+require 'rspec/mocks/targets'
+require 'rspec/mocks/syntax'
+require 'rspec/mocks/configuration'
+require 'rspec/mocks/verifying_double'

data/vendor_lib/rspec/mocks/instance_method_stasher.rb

@@ -0,0 +1,112 @@
+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 if !method_defined_directly_on_klass?
+          @original_method ||= ::RSpec::Mocks.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
+
+          @klass.__send__(:define_method, @method, @original_method)
+          @original_method = nil
+        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)
+        klass.method_defined?(@method) || klass.private_method_defined?(@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/vendor_lib/rspec/mocks/matchers/have_received.rb

@@ -0,0 +1,99 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class HaveReceived
+        COUNT_CONSTRAINTS = %w(exactly at_least at_most times once twice)
+        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
+          expected_messages_received_in_order?
+        end
+
+        def does_not_match?(subject)
+          @subject = subject
+          ensure_count_unconstrained
+          @expectation = expect.never
+          expected_messages_received_in_order?
+        end
+
+        def failure_message
+          generate_failure_message
+        end
+
+        def negative_failure_message
+          generate_failure_message
+        end
+
+        def description
+          expect.description
+        end
+
+        CONSTRAINTS.each do |expectation|
+          define_method expectation do |*args|
+            @constraints << [expectation, *args]
+            self
+          end
+        end
+
+      private
+
+        def expect
+          expectation = mock_proxy.build_expectation(@method_name)
+          apply_constraints_to expectation
+          expectation
+        end
+
+        def apply_constraints_to(expectation)
+          @constraints.each do |constraint|
+            expectation.send(*constraint)
+          end
+        end
+
+        def ensure_count_unconstrained
+          if count_constraint
+            raise RSpec::Mocks::MockExpectationError,
+              "can't use #{count_constraint} when negative"
+          end
+        end
+
+        def count_constraint
+          @constraints.map(&:first).detect 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.proxy_for(@subject)
+        end
+      end
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/matchers/receive.rb

@@ -0,0 +1,112 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class Receive
+        def initialize(message, block)
+          @message                 = message
+          @block                   = block
+          @recorded_customizations = []
+
+          # MRI, JRuby and RBX report the caller inconsistently; MRI
+          # reports an extra "in `new'" line in the backtrace that the
+          # others do not include. The safest way to find the right
+          # line is to search for the first line BEFORE rspec/mocks/syntax.rb.
+          @backtrace_line = CallerFilter.first_non_rspec_line
+        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 Customization.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 << Customization.new(method, args, block)
+            self
+          end
+        end
+
+      private
+
+        def warn_if_any_instance(expression, subject)
+          if AnyInstance::Recorder === 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
+        end
+
+        def setup_mock_proxy_method_substitute(subject, method, block)
+          proxy = ::RSpec::Mocks.proxy_for(subject)
+          setup_method_substitute(proxy, method, block, @backtrace_line)
+        end
+
+        def setup_any_instance_method_substitute(subject, method, block)
+          any_instance_recorder = ::RSpec::Mocks.any_instance_recorder_for(subject)
+          setup_method_substitute(any_instance_recorder, method, block)
+        end
+
+        def setup_method_substitute(host, method, block, *args)
+          args << @message.to_sym
+          expectation = host.__send__(method, *args, &(@block || block))
+
+          @recorded_customizations.each do |customization|
+            customization.playback_onto(expectation)
+          end
+          expectation
+        end
+
+        class Customization
+          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
+end
+

data/vendor_lib/rspec/mocks/matchers/receive_messages.rb

@@ -0,0 +1,72 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class ReceiveMessages
+
+        def initialize(message_return_value_hash)
+          @message_return_value_hash = message_return_value_hash
+          @backtrace_line = CallerFilter.first_non_rspec_line
+        end
+
+        def name
+          "receive_messages"
+        end
+
+        def setup_expectation(subject)
+          warn_about_block if block_given?
+          each_message_on( proxy_on(subject) ) do |host, message, return_value|
+            host.add_simple_expectation(message, return_value, @backtrace_line)
+          end
+        end
+        alias matches? setup_expectation
+
+        def setup_negative_expectation(subject)
+          raise NegationUnsupportedError,
+            "`expect(...).to_not receive_messages` is not supported since it " +
+            "doesn't really make sense. What would it even mean?"
+        end
+        alias does_not_match? setup_negative_expectation
+
+        def setup_allowance(subject)
+          warn_about_block if block_given?
+          each_message_on( proxy_on(subject) ) do |host, message, return_value|
+            host.add_simple_stub(message, return_value)
+          end
+        end
+
+        def setup_any_instance_expectation(subject)
+          warn_about_block if block_given?
+          each_message_on( any_instance_of(subject) ) do |host, message, return_value|
+            host.should_receive(message).and_return(return_value)
+          end
+        end
+
+        def setup_any_instance_allowance(subject)
+          warn_about_block if block_given?
+          any_instance_of(subject).stub(@message_return_value_hash)
+        end
+
+        def warn_about_block
+          raise "Implementation blocks aren't supported with `receive_messages`"
+        end
+
+      private
+
+        def proxy_on(subject)
+          ::RSpec::Mocks.proxy_for(subject)
+        end
+
+        def any_instance_of(subject)
+          ::RSpec::Mocks.any_instance_recorder_for(subject)
+        end
+
+        def each_message_on(host)
+          @message_return_value_hash.each do |message, value|
+            yield host, message, value
+          end
+        end
+
+      end
+    end
+  end
+end