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

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

@@ -0,0 +1,221 @@
+module RSpec
+  module Mocks
+    # @private
+    # Provides a default space implementation for outside
+    # the scope of an example. Called "root" because it serves
+    # as the root of the space stack.
+    class RootSpace
+      def proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
+      def any_instance_recorder_for(*_args)
+        raise_lifecycle_message
+      end
+
+      def any_instance_proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
+      def register_constant_mutator(_mutator)
+        raise_lifecycle_message
+      end
+
+      def any_instance_recorders_from_ancestry_of(_object)
+        raise_lifecycle_message
+      end
+
+      def reset_all
+      end
+
+      def verify_all
+      end
+
+      def registered?(_object)
+        false
+      end
+
+      def new_scope
+        Space.new
+      end
+
+    private
+
+      def raise_lifecycle_message
+        raise OutsideOfExampleError,
+              "The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported."
+      end
+    end
+
+    # @private
+    class Space
+      attr_reader :proxies, :any_instance_recorders, :proxy_mutex, :any_instance_mutex
+
+      def initialize
+        @proxies                 = {}
+        @any_instance_recorders  = {}
+        @constant_mutators       = []
+        @expectation_ordering    = OrderGroup.new
+        @proxy_mutex             = new_mutex
+        @any_instance_mutex      = new_mutex
+      end
+
+      def new_scope
+        NestedSpace.new(self)
+      end
+
+      def verify_all
+        proxies.values.each { |proxy| proxy.verify }
+        any_instance_recorders.each_value { |recorder| recorder.verify }
+      end
+
+      def reset_all
+        proxies.each_value { |proxy| proxy.reset }
+        @constant_mutators.reverse.each { |mut| mut.idempotently_reset }
+        any_instance_recorders.each_value { |recorder| recorder.stop_all_observation! }
+        any_instance_recorders.clear
+      end
+
+      def register_constant_mutator(mutator)
+        @constant_mutators << mutator
+      end
+
+      def constant_mutator_for(name)
+        @constant_mutators.find { |m| m.full_constant_name == name }
+      end
+
+      def any_instance_recorder_for(klass, only_return_existing=false)
+        any_instance_mutex.synchronize do
+          id = klass.__id__
+          any_instance_recorders.fetch(id) do
+            return nil if only_return_existing
+            any_instance_recorder_not_found_for(id, klass)
+          end
+        end
+      end
+
+      def any_instance_proxy_for(klass)
+        AnyInstance::Proxy.new(any_instance_recorder_for(klass), proxies_of(klass))
+      end
+
+      def proxies_of(klass)
+        proxies.values.select { |proxy| klass === proxy.object }
+      end
+
+      def proxy_for(object)
+        proxy_mutex.synchronize do
+          id = id_for(object)
+          proxies.fetch(id) { proxy_not_found_for(id, object) }
+        end
+      end
+
+      alias ensure_registered proxy_for
+
+      def registered?(object)
+        proxies.key?(id_for object)
+      end
+
+      def any_instance_recorders_from_ancestry_of(object)
+        # Optimization: `any_instance` is a feature we generally
+        # recommend not using, so we can often early exit here
+        # without doing an O(N) linear search over the number of
+        # ancestors in the object's class hierarchy.
+        return [] if any_instance_recorders.empty?
+
+        # We access the ancestors through the singleton class, to avoid calling
+        # `class` in case `class` has been stubbed.
+        (class << object; ancestors; end).map do |klass|
+          any_instance_recorders[klass.__id__]
+        end.compact
+      end
+
+    private
+
+      # We don't want to depend on the stdlib ourselves, but if the user is
+      # using threads then a Mutex will be available to us. If not, we don't
+      # need to synchronize anyway.
+      def new_mutex
+        defined?(::Mutex) ? ::Mutex.new : FakeMutex
+      end
+
+      # @private
+      module FakeMutex
+        def self.synchronize
+          yield
+        end
+      end
+
+      def proxy_not_found_for(id, object)
+        proxies[id] = case object
+                      when NilClass   then ProxyForNil.new(@expectation_ordering)
+                      when TestDouble then object.__build_mock_proxy_unless_expired(@expectation_ordering)
+                      when Class
+                        if RSpec::Mocks.configuration.verify_partial_doubles?
+                          VerifyingPartialClassDoubleProxy.new(self, object, @expectation_ordering)
+                        else
+                          PartialClassDoubleProxy.new(self, object, @expectation_ordering)
+                        end
+                      else
+                        if RSpec::Mocks.configuration.verify_partial_doubles?
+                          VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
+                        else
+                          PartialDoubleProxy.new(object, @expectation_ordering)
+                        end
+                      end
+      end
+
+      def any_instance_recorder_not_found_for(id, klass)
+        any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
+      end
+
+      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
+        require 'securerandom'
+
+        def id_for(object)
+          id = object.__id__
+
+          return id if object.equal?(::ObjectSpace._id2ref(id))
+          # this suggests that object.__id__ is proxying through to some wrapped object
+
+          object.instance_exec do
+            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
+          end
+        end
+      else
+        def id_for(object)
+          object.__id__
+        end
+      end
+    end
+
+    # @private
+    class NestedSpace < Space
+      def initialize(parent)
+        @parent = parent
+        super()
+      end
+
+      def proxies_of(klass)
+        super + @parent.proxies_of(klass)
+      end
+
+      def constant_mutator_for(name)
+        super || @parent.constant_mutator_for(name)
+      end
+
+      def registered?(object)
+        super || @parent.registered?(object)
+      end
+
+    private
+
+      def proxy_not_found_for(id, object)
+        @parent.proxies[id] || super
+      end
+
+      def any_instance_recorder_not_found_for(id, klass)
+        @parent.any_instance_recorders[id] || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+require 'rspec/mocks'
+include RSpec::Mocks::ExampleMethods
+RSpec::Mocks.setup

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

@@ -0,0 +1,329 @@
+module RSpec
+  module Mocks
+    # @api private
+    # Provides methods for enabling and disabling the available syntaxes
+    # provided by rspec-mocks.
+    module Syntax
+      # @private
+      def self.warn_about_should!
+        @warn_about_should = true
+      end
+
+      # @private
+      def self.warn_unless_should_configured(method_name , replacement="the new `:expect` syntax or explicitly enable `:should`")
+        if @warn_about_should
+          RSpec.deprecate(
+            "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
+            :replacement => replacement
+          )
+
+          @warn_about_should = false
+        end
+      end
+
+      # @api private
+      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.enable_should(syntax_host=default_should_syntax_host)
+        @warn_about_should = false if syntax_host == default_should_syntax_host
+        return if should_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          def should_receive(message, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.expect_message(self, message, opts, &block)
+          end
+
+          def should_not_receive(message, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.expect_message(self, message, {}, &block).never
+          end
+
+          def stub(message_or_hash, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            if ::Hash === message_or_hash
+              message_or_hash.each { |message, value| stub(message).and_return value }
+            else
+              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
+            end
+          end
+
+          def unstub(message)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to_receive(...).and_call_original` or explicitly enable `:should`")
+            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
+          end
+
+          def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
+          end
+
+          def as_null_object
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            @_null_object = true
+            ::RSpec::Mocks.space.proxy_for(self).as_null_object
+          end
+
+          def null_object?
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            defined?(@_null_object)
+          end
+
+          def received_message?(message, *args, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.space.proxy_for(self).received_message?(message, *args, &block)
+          end
+
+          unless Class.respond_to? :any_instance
+            Class.class_exec do
+              def any_instance
+                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+                ::RSpec::Mocks.space.any_instance_proxy_for(self)
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.disable_should(syntax_host=default_should_syntax_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef should_receive
+          undef should_not_receive
+          undef stub
+          undef unstub
+          undef stub_chain
+          undef as_null_object
+          undef null_object?
+          undef received_message?
+        end
+
+        Class.class_exec do
+          undef any_instance
+        end
+      end
+
+      # @api private
+      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          def receive(method_name, &block)
+            Matchers::Receive.new(method_name, block)
+          end
+
+          def receive_messages(message_return_value_hash)
+            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
+            matcher.warn_about_block if block_given?
+            matcher
+          end
+
+          def receive_message_chain(*messages, &block)
+            Matchers::ReceiveMessageChain.new(messages, &block)
+          end
+
+          def allow(target)
+            AllowanceTarget.new(target)
+          end
+
+          def expect_any_instance_of(klass)
+            AnyInstanceExpectationTarget.new(klass)
+          end
+
+          def allow_any_instance_of(klass)
+            AnyInstanceAllowanceTarget.new(klass)
+          end
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          def expect(target)
+            ExpectationTarget.new(target)
+          end
+        end
+      end
+
+      # @api private
+      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.disable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef receive
+          undef receive_messages
+          undef receive_message_chain
+          undef allow
+          undef expect_any_instance_of
+          undef allow_any_instance_of
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          undef expect
+        end
+      end
+
+      # @api private
+      # Indicates whether or not the should syntax is enabled.
+      def self.should_enabled?(syntax_host=default_should_syntax_host)
+        syntax_host.method_defined?(:should_receive)
+      end
+
+      # @api private
+      # Indicates whether or not the expect syntax is enabled.
+      def self.expect_enabled?(syntax_host=::RSpec::Mocks::ExampleMethods)
+        syntax_host.method_defined?(:allow)
+      end
+
+      # @api private
+      # Determines where the methods like `should_receive`, and `stub` are added.
+      def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
+        # On 1.8.7, Object.ancestors.last == Kernel but
+        # things blow up if we include `RSpec::Mocks::Methods`
+        # into Kernel...not sure why.
+        return Object unless defined?(::BasicObject)
+
+        # MacRuby has BasicObject but it's not the root class.
+        return Object unless Object.ancestors.last == ::BasicObject
+
+        ::BasicObject
+      end
+    end
+  end
+end
+
+if defined?(BasicObject)
+  # The legacy `:should` syntax adds the following methods directly to
+  # `BasicObject` so that they are available off of any object. Note, however,
+  # that this syntax does not always play nice with delegate/proxy objects.
+  # We recommend you use the non-monkeypatching `:expect` syntax instead.
+  # @see Class
+  class BasicObject
+    # @method should_receive
+    # Sets an expectation that this object should receive a message before
+    # the end of the example.
+    #
+    # @example
+    #
+    #     logger = double('logger')
+    #     thing_that_logs = ThingThatLogs.new(logger)
+    #     logger.should_receive(:log)
+    #     thing_that_logs.do_something_that_logs_a_message
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+    # @see RSpec::Mocks::ExampleMethods#expect
+
+    # @method should_not_receive
+    # Sets and expectation that this object should _not_ receive a message
+    # during this example.
+    # @see RSpec::Mocks::ExampleMethods#expect
+
+    # @method stub
+    # Tells the object to respond to the message with the specified value.
+    #
+    # @example
+    #
+    #     counter.stub(:count).and_return(37)
+    #     counter.stub(:count => 37)
+    #     counter.stub(:count) { 37 }
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+    # @see RSpec::Mocks::ExampleMethods#allow
+
+    # @method unstub
+    # Removes a stub. On a double, the object will no longer respond to
+    # `message`. On a real object, the original method (if it exists) is
+    # restored.
+    #
+    # This is rarely used, but can be useful when a stub is set up during a
+    # shared `before` hook for the common case, but you want to replace it
+    # for a special case.
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+
+    # @method stub_chain
+    # @overload stub_chain(method1, method2)
+    # @overload stub_chain("method1.method2")
+    # @overload stub_chain(method1, method_to_value_hash)
+    #
+    # Stubs a chain of methods.
+    #
+    # ## Warning:
+    #
+    # Chains can be arbitrarily long, which makes it quite painless to
+    # violate the Law of Demeter in violent ways, so you should consider any
+    # use of `stub_chain` a code smell. Even though not all code smells
+    # indicate real problems (think fluent interfaces), `stub_chain` still
+    # results in brittle examples.  For example, if you write
+    # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
+    # implementation calls `foo.baz.bar`, the stub will not work.
+    #
+    # @example
+    #
+    #     double.stub_chain("foo.bar") { :baz }
+    #     double.stub_chain(:foo, :bar => :baz)
+    #     double.stub_chain(:foo, :bar) { :baz }
+    #
+    #     # Given any of ^^ these three forms ^^:
+    #     double.foo.bar # => :baz
+    #
+    #     # Common use in Rails/ActiveRecord:
+    #     Article.stub_chain("recent.published") { [Article.new] }
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+    # @see RSpec::Mocks::ExampleMethods#receive_message_chain
+
+    # @method as_null_object
+    # Tells the object to respond to all messages. If specific stub values
+    # are declared, they'll work as expected. If not, the receiver is
+    # returned.
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+
+    # @method null_object?
+    # Returns true if this object has received `as_null_object`
+    #
+    # @note This is only available when you have enabled the `should` syntax.
+  end
+end
+
+# The legacy `:should` syntax adds the `any_instance` to `Class`.
+# We generally recommend you use the newer `:expect` syntax instead,
+# which allows you to stub any instance of a class using
+# `allow_any_instance_of(klass)` or mock any instance using
+# `expect_any_instance_of(klass)`.
+# @see BasicObject
+class Class
+  # @method any_instance
+  # Used to set stubs and message expectations on any instance of a given
+  # class. Returns a [Recorder](Recorder), which records messages like
+  # `stub` and `should_receive` for later playback on instances of the
+  # class.
+  #
+  # @example
+  #
+  #     Car.any_instance.should_receive(:go)
+  #     race = Race.new
+  #     race.cars << Car.new
+  #     race.go # assuming this delegates to all of its cars
+  #             # this example would pass
+  #
+  #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+  #     Account.new.balance # => Money.new(:USD, 25))
+  #
+  # @return [Recorder]
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+  # @see RSpec::Mocks::ExampleMethods#expect_any_instance_of
+  # @see RSpec::Mocks::ExampleMethods#allow_any_instance_of
+end