opal-rspec-cj 0.4.4

data/vendor_lib/rspec/mocks/any_instance/recorder.rb

@@ -0,0 +1,200 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
+      # which records stubs and message expectations for later playback on
+      # instances of `TheClass`.
+      #
+      # Further constraints are stored in instances of [Chain](Chain).
+      #
+      # @see AnyInstance
+      # @see Chain
+      class Recorder
+        # @private
+        attr_reader :message_chains, :stubs, :klass
+
+        def initialize(klass)
+          @message_chains = MessageChains.new
+          @stubs = Hash.new { |hash,key| hash[key] = [] }
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+
+        # Initializes the recording a stub to be played back against any
+        # instance of this object that invokes the submitted method.
+        #
+        # @see Methods#stub
+        def stub(method_name_or_method_map, &block)
+          if Hash === method_name_or_method_map
+            method_name_or_method_map.each do |method_name, return_value|
+              stub(method_name).and_return(return_value)
+            end
+          else
+            observe!(method_name_or_method_map)
+            message_chains.add(method_name_or_method_map, StubChain.new(self, method_name_or_method_map, &block))
+          end
+        end
+
+        # Initializes the recording a stub chain to be played back against any
+        # instance of this object that invokes the method matching the first
+        # argument.
+        #
+        # @see Methods#stub_chain
+        def stub_chain(*method_names_and_optional_return_values, &block)
+          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
+            observe!(method_name)
+            message_chains.add(method_name, StubChainChain.new(self, *args, &block))
+          end
+        end
+
+        # Initializes the recording a message expectation to be played back
+        # against any instance of this object that invokes the submitted
+        # method.
+        #
+        # @see Methods#should_receive
+        def should_receive(method_name, &block)
+          @expectation_set = true
+          observe!(method_name)
+          message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
+        end
+
+        def should_not_receive(method_name, &block)
+          should_receive(method_name, &block).never
+        end
+
+        # Removes any previously recorded stubs, stub_chains or message
+        # expectations that use `method_name`.
+        #
+        # @see Methods#unstub
+        def unstub(method_name)
+          unless @observed_methods.include?(method_name.to_sym)
+            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+          end
+          message_chains.remove_stub_chains_for!(method_name)
+          ::RSpec::Mocks.proxies_of(@klass).each do |proxy|
+            stubs[method_name].each { |stub| proxy.remove_single_stub(method_name, stub) }
+          end
+          stubs[method_name].clear
+          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
+        end
+
+        # @api private
+        #
+        # Used internally to verify that message expectations have been
+        # fulfilled.
+        def verify
+          if @expectation_set && !message_chains.all_expectations_fulfilled?
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
+          end
+        ensure
+          stop_all_observation!
+          ::RSpec::Mocks.space.remove_any_instance_recorder_for(@klass)
+        end
+
+        # @private
+        def stop_all_observation!
+          @observed_methods.each {|method_name| restore_method!(method_name)}
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          RSpec::Mocks.space.ensure_registered(instance)
+          message_chains.playback!(instance, method_name)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
+        end
+
+        # @private
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        def build_alias_method_name(method_name)
+          "__#{method_name}_without_any_instance__"
+        end
+
+        def already_observing?(method_name)
+          @observed_methods.include?(method_name)
+        end
+
+        private
+
+        def normalize_chain(*args)
+          args.shift.to_s.split('.').map {|s| s.to_sym}.reverse.each {|a| args.unshift a}
+          yield args.first, args
+        end
+
+        def received_expected_message!(method_name)
+          message_chains.received_expected_message!(method_name)
+          restore_method!(method_name)
+          mark_invoked!(method_name)
+        end
+
+        def restore_method!(method_name)
+          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
+            restore_original_method!(method_name)
+          else
+            remove_dummy_method!(method_name)
+          end
+        end
+
+        def restore_original_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec do
+            remove_method method_name
+            alias_method  method_name, alias_method_name
+            remove_method alias_method_name
+          end
+        end
+
+        def remove_dummy_method!(method_name)
+          @klass.class_exec do
+            remove_method method_name
+          end
+        end
+
+        def backup_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec do
+            alias_method alias_method_name, method_name
+          end if public_protected_or_private_method_defined?(method_name)
+        end
+
+        def public_protected_or_private_method_defined?(method_name)
+          @klass.method_defined?(method_name) || @klass.private_method_defined?(method_name)
+        end
+
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+        end
+
+        def observe!(method_name)
+          if RSpec::Mocks.configuration.verify_partial_doubles?
+            raise MockExpectationError unless @klass.method_defined?(method_name)
+          end
+
+          stop_observing!(method_name) if already_observing?(method_name)
+          @observed_methods << method_name
+          backup_method!(method_name)
+          @klass.__send__(:define_method, method_name) do |*args, &blk|
+            klass = ::RSpec::Mocks.method_handle_for(self, method_name).owner
+            ::RSpec::Mocks.any_instance_recorder_for(klass).playback!(self, method_name)
+            self.__send__(method_name, *args, &blk)
+          end
+        end
+
+        def mark_invoked!(method_name)
+          backup_method!(method_name)
+          @klass.__send__(:define_method, method_name) do |*args, &blk|
+            klass = ::RSpec::Mocks.method_handle_for(self, method_name).owner
+            invoked_instance = ::RSpec::Mocks.any_instance_recorder_for(klass).instance_that_received(method_name)
+            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{self.inspect} but has already been received by #{invoked_instance}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/any_instance/stub_chain.rb

@@ -0,0 +1,45 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class StubChain < Chain
+
+        # @private
+        def expectation_fulfilled?
+          true
+        end
+
+        private
+
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          stub = proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
+          @recorder.stubs[stub.message] << stub
+
+          if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
+            stub.and_yield_receiver_to_implementation
+          end
+
+          stub
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil],
+            :and_yield => [:with, nil],
+            :and_call_original => [:with, nil]
+          }
+        end
+
+        def verify_invocation_order(rspec_method_name, *args, &block)
+          unless invocation_order[rspec_method_name].include?(last_message)
+            raise(NoMethodError, "Undefined method #{rspec_method_name}")
+          end
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -0,0 +1,23 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class StubChainChain < StubChain
+
+        private
+
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::StubChain.stub_chain_on(instance, *@expectation_args, &@expectation_block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :and_return => [nil],
+            :and_raise => [nil],
+            :and_yield => [nil]
+          }
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/argument_list_matcher.rb

@@ -0,0 +1,104 @@
+require 'rspec/mocks/argument_matchers'
+
+module RSpec
+  module Mocks
+    # Wrapper for matching arguments against a list of expected values. Used by
+    # the `with` method on a `MessageExpectation`:
+    #
+    #     object.should_receive(:message).with(:a, 'b', 3)
+    #     object.message(:a, 'b', 3)
+    #
+    # Values passed to `with` can be literal values or argument matchers that
+    # match against the real objects .e.g.
+    #
+    #     object.should_receive(:message).with(hash_including(:a => 'b'))
+    #
+    # Can also be used directly to match the contents of any `Array`. This
+    # enables 3rd party mocking libs to take advantage of rspec's argument
+    # matching without using the rest of rspec-mocks.
+    #
+    #     require 'rspec/mocks/argument_list_matcher'
+    #     include RSpec::Mocks::ArgumentMatchers
+    #
+    #     arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(123, hash_including(:a => 'b'))
+    #     arg_list_matcher.args_match?(123, :a => 'b')
+    #
+    # This class is immutable.
+    #
+    # @see ArgumentMatchers
+    class ArgumentListMatcher
+      # @private
+      attr_reader :expected_args
+
+      # @api public
+      # @param [Array] *expected_args a list of expected literals and/or argument matchers
+      # @param [Block] block a block with arity matching the expected
+      #
+      # Initializes an `ArgumentListMatcher` with a collection of literal
+      # values and/or argument matchers, or a block that handles the evaluation
+      # for you.
+      #
+      # @see ArgumentMatchers
+      # @see #args_match?
+      def initialize(*expected_args, &block)
+        @expected_args = expected_args
+        @block = expected_args.empty? ? block : nil
+        @match_any_args = false
+        @matchers = nil
+
+        case expected_args.first
+        when ArgumentMatchers::AnyArgsMatcher
+          @match_any_args = true
+        when ArgumentMatchers::NoArgsMatcher
+          @matchers = []
+        else
+          @matchers = expected_args.collect {|arg| matcher_for(arg)}
+        end
+      end
+
+      # @api public
+      # @param [Array] *args
+      #
+      # Matches each element in the `expected_args` against the element in the same
+      # position of the arguments passed to `new`.
+      #
+      # @see #initialize
+      def args_match?(*args)
+        match_any_args? || block_passes?(*args) || matchers_match?(*args)
+      end
+
+      private
+
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg)  if Regexp === arg
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+
+      def is_matcher?(object)
+        return false if object.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
+
+        [:failure_message_for_should, :failure_message].any? do |msg|
+          object.respond_to?(msg)
+        end && object.respond_to?(:matches?)
+      end
+
+      def block_passes?(*args)
+        @block.call(*args) if @block
+      end
+
+      def matchers_match?(*args)
+        @matchers == args
+      end
+
+      def match_any_args?
+        @match_any_args
+      end
+
+      # Value that will match all argument lists.
+      #
+      # @private
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher.new)
+    end
+  end
+end

data/vendor_lib/rspec/mocks/argument_matchers.rb

@@ -0,0 +1,264 @@
+module RSpec
+  module Mocks
+
+    # ArgumentMatchers are placeholders that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of `any_args` and `no_args`, they all match against
+    # the arg in same position in the argument list.
+    #
+    # @see ArgumentListMatcher
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          Regexp === value ? value == @regexp : value =~ @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          [true,false].include?(value)
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+
+      class HashExcludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.none? {|k,v| actual.has_key?(k) && v == actual[k]}
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+
+      class ArrayIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          Set.new(actual).superset?(Set.new(@expected))
+        end
+
+        def description
+          "array_including(#{@expected.join(",")})"
+        end
+      end
+
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @given == expected
+        end
+      end
+
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
+
+      # Matches any args at all. Supports a more explicit variation of
+      # `object.should_receive(:message)`
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(any_args)
+      def any_args
+        AnyArgsMatcher.new
+      end
+
+      # Matches any argument at all.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(anything)
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+
+      # Matches no arguments.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(no_args)
+      def no_args
+        NoArgsMatcher.new
+      end
+
+      # Matches if the actual argument responds to the specified messages.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # Matches a boolean value.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(boolean())
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+
+      # Matches a hash that includes the specified key(s) or key/value pairs.
+      # Ignores any additional keys.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      def hash_including(*args)
+        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+
+      # Matches an array that includes the specified items at least once.
+      # Ignores duplicates and additional values
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(array_including(1,2,3))
+      #   object.should_receive(:message).with(array_including([1,2,3]))
+      def array_including(*args)
+        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
+        ArrayIncludingMatcher.new(actually_an_array)
+      end
+
+      # Matches a hash that doesn't include the specified key(s) or key/value.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(hash_excluding(:key => val))
+      #   object.should_receive(:message).with(hash_excluding(:key))
+      #   object.should_receive(:message).with(hash_excluding(:key, :key2 => :val2))
+      def hash_excluding(*args)
+        HashExcludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+
+      alias_method :hash_not_including, :hash_excluding
+
+      # Matches if `arg.instance_of?(klass)`
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(instance_of(Thing))
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+
+      alias_method :an_instance_of, :instance_of
+
+      # Matches if `arg.kind_of?(klass)`
+      # @example
+      #
+      #   object.should_receive(:message).with(kind_of(Thing))
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+
+      alias_method :a_kind_of, :kind_of
+
+      private
+
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
+      end
+    end
+  end
+end