opal-rspec 0.4.3 → 0.5.0.beta1

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/verifying_double.rb

@@ -1,22 +1,63 @@
-require 'rspec/mocks/mock'
-require 'rspec/mocks/verifying_proxy'
+RSpec::Support.require_rspec_mocks 'verifying_proxy'
+require 'stringio'
 
 module RSpec
   module Mocks
-
+    # @private
     module VerifyingDouble
+      def respond_to?(message, include_private=false)
+        return super unless null_object?
+
+        method_ref = __mock_proxy.method_reference[message]
+
+        case method_ref.visibility
+        when :public    then true
+        when :private   then include_private
+        when :protected then include_private || RUBY_VERSION.to_f < 2.0
+        else !method_ref.unimplemented?
+        end
+      end
+
       def method_missing(message, *args, &block)
         # Null object conditional is an optimization. If not a null object,
         # validity of method expectations will have been checked at definition
         # time.
-        __mock_proxy.ensure_implemented(message) if null_object?
+        if null_object?
+          if @__sending_message == message
+            __mock_proxy.ensure_implemented(message)
+          else
+            __mock_proxy.ensure_publicly_implemented(message, self)
+          end
+        end
+
+        super
+      end
+
+      # Redefining `__send__` causes ruby to issue a warning.
+      old, $stderr = $stderr, StringIO.new
+      def __send__(name, *args, &block)
+        @__sending_message = name
+        super
+      ensure
+        @__sending_message = nil
+      end
+      $stderr = old
+
+      def send(name, *args, &block)
+        __send__(name, *args, &block)
+      end
+
+      def initialize(*args)
         super
+        @__sending_message = nil
       end
     end
 
     # A mock providing a custom proxy that can verify the validity of any
     # method stubs or expectations against the public instance methods of the
     # given class.
+    #
+    # @private
     class InstanceVerifyingDouble
       include TestDouble
       include VerifyingDouble
@@ -24,44 +65,52 @@ module RSpec
       def initialize(doubled_module, *args)
         @doubled_module = doubled_module
 
-        __initialize_as_test_double(doubled_module, *args)
+        super(
+          "#{doubled_module.description} (instance)",
+          *args
+        )
       end
 
       def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group,
-          @doubled_module,
-          InstanceMethodReference
+        VerifyingProxy.new(self, order_group, @name,
+                           @doubled_module,
+                           InstanceMethodReference
         )
       end
     end
 
     # An awkward module necessary because we cannot otherwise have
     # ClassVerifyingDouble inherit from Module and still share these methods.
+    #
+    # @private
     module ObjectVerifyingDoubleMethods
       include TestDouble
       include VerifyingDouble
 
+      def as_stubbed_const(options={})
+        ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
+        self
+      end
+
+    private
+
       def initialize(doubled_module, *args)
         @doubled_module = doubled_module
-
-        __initialize_as_test_double(doubled_module, *args)
+        super(doubled_module.description, *args)
       end
 
       def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group,
-          @doubled_module,
-          ObjectMethodReference
+        VerifyingProxy.new(self, order_group, @name,
+                           @doubled_module,
+                           ObjectMethodReference
         )
       end
-
-      def as_stubbed_const(options = {})
-        ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
-        self
-      end
     end
 
     # Similar to an InstanceVerifyingDouble, except that it verifies against
     # public methods of the given object.
+    #
+    # @private
     class ObjectVerifyingDouble
       include ObjectVerifyingDoubleMethods
     end
@@ -69,9 +118,10 @@ module RSpec
     # Effectively the same as an ObjectVerifyingDouble (since a class is a type
     # of object), except with Module in the inheritance chain so that
     # transferring nested constants to work.
+    #
+    # @private
     class ClassVerifyingDouble < Module
       include ObjectVerifyingDoubleMethods
     end
-
   end
 end

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/verifying_message_expecation.rb

@@ -1,13 +1,12 @@
-require 'rspec/mocks/arity_calculator'
+RSpec::Support.require_rspec_support 'method_signature_verifier'
 
 module RSpec
   module Mocks
-
     # A message expectation that knows about the real implementation of the
     # message being expected, so that it can verify that any expectations
-    # have the correct arity.
+    # have the valid arguments.
+    # @api private
     class VerifyingMessageExpectation < MessageExpectation
-
       # A level of indirection is used here rather than just passing in the
       # method itself, since method look up is expensive and we only want to
       # do it if actually needed.
@@ -22,39 +21,42 @@ module RSpec
         super
       end
 
-      # @override
+      # @private
       def with(*args, &block)
         unless ArgumentMatchers::AnyArgsMatcher === args.first
-          expected_arity = if ArgumentMatchers::NoArgsMatcher === args.first
-            0
-          elsif args.length > 0
-            args.length
-          else
-            # No arguments given, this will raise.
-            super
-          end
-
-          ensure_arity!(expected_arity)
+          expected_args = if ArgumentMatchers::NoArgsMatcher === args.first
+                            []
+                          elsif args.length > 0
+                            args
+                          else
+                            # No arguments given, this will raise.
+                            super
+                          end
+
+          validate_expected_arguments!(expected_args)
         end
         super
       end
 
     private
 
-      def ensure_arity!(actual)
+      def validate_expected_arguments!(actual_args)
         return if method_reference.nil?
 
-        method_reference.when_defined do |method|
-          calculator = ArityCalculator.new(method)
-          unless calculator.within_range?(actual)
+        method_reference.with_signature do |signature|
+          verifier = Support::LooseSignatureVerifier.new(
+            signature,
+            actual_args
+          )
+
+          unless verifier.valid?
             # Fail fast is required, otherwise the message expecation will fail
             # as well ("expected method not called") and clobber this one.
             @failed_fast = true
-            @error_generator.raise_arity_error(calculator, actual)
+            @error_generator.raise_invalid_arguments_error(verifier)
           end
         end
       end
     end
   end
 end
-

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/verifying_proxy.rb

@@ -1,11 +1,11 @@
-require 'rspec/mocks/verifying_message_expecation'
-require 'rspec/mocks/method_reference'
+RSpec::Support.require_rspec_mocks 'verifying_message_expecation'
+RSpec::Support.require_rspec_mocks 'method_reference'
 
 module RSpec
   module Mocks
-
+    # @private
     module VerifyingProxyMethods
-      def add_stub(location, method_name, opts={}, &implementation)
+      def add_stub(method_name, opts={}, &implementation)
         ensure_implemented(method_name)
         super
       end
@@ -15,27 +15,33 @@ module RSpec
         super
       end
 
-      def add_message_expectation(location, method_name, opts={}, &block)
+      def add_message_expectation(method_name, opts={}, &block)
         ensure_implemented(method_name)
         super
       end
 
       def ensure_implemented(method_name)
-        return unless @doubled_module.defined?
+        return unless method_reference[method_name].unimplemented?
 
-        method_reference[method_name].when_unimplemented do
-          @error_generator.raise_unimplemented_error(
-            @doubled_module,
-            method_name
-          )
-        end
+        @error_generator.raise_unimplemented_error(
+          @doubled_module,
+          method_name
+        )
+      end
+
+      def ensure_publicly_implemented(method_name, _object)
+        ensure_implemented(method_name)
+        visibility = method_reference[method_name].visibility
+
+        return if visibility == :public
+        @error_generator.raise_non_public_error(method_name, visibility)
       end
     end
 
     # A verifying proxy mostly acts like a normal proxy, except that it
     # contains extra logic to try and determine the validity of any expectation
     # set on it. This includes whether or not methods have been defined and the
-    # arity of method calls.
+    # validatiy of arguments on method calls.
     #
     # In all other ways this behaves like a normal proxy. It only adds the
     # verification behaviour to specific methods then delegates to the parent
@@ -45,18 +51,18 @@ module RSpec
     # loaded, otherwise they are disabled. This allows for testing in
     # isolation.
     #
-    # @api private
-    class VerifyingProxy < Proxy
+    # @private
+    class VerifyingProxy < TestDoubleProxy
       include VerifyingProxyMethods
 
-      def initialize(object, order_group, name, method_reference_class)
-        super(object, order_group)
+      def initialize(object, order_group, name, doubled_module, method_reference_class)
+        super(object, order_group, name)
         @object                 = object
-        @doubled_module         = name
+        @doubled_module         = doubled_module
         @method_reference_class = method_reference_class
 
         # A custom method double is required to pass through a way to lookup
-        # methods to determine their arity. This is only relevant if the doubled
+        # methods to determine their parameters. This is only relevant if the doubled
         # class is loaded.
         @method_doubles = Hash.new do |h, k|
           h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
@@ -68,9 +74,14 @@ module RSpec
           h[k] = @method_reference_class.new(@doubled_module, k)
         end
       end
+
+      def visibility_for(method_name)
+        method_reference[method_name].visibility
+      end
     end
 
-    class VerifyingPartialMockProxy < PartialMockProxy
+    # @private
+    class VerifyingPartialDoubleProxy < PartialDoubleProxy
       include VerifyingProxyMethods
 
       def initialize(object, expectation_ordering)
@@ -78,7 +89,7 @@ module RSpec
         @doubled_module = DirectObjectReference.new(object)
 
         # A custom method double is required to pass through a way to lookup
-        # methods to determine their arity.
+        # methods to determine their parameters.
         @method_doubles = Hash.new do |h, k|
           h[k] = VerifyingExistingMethodDouble.new(object, k, self)
         end
@@ -89,7 +100,12 @@ module RSpec
       end
     end
 
-    # @api private
+    # @private
+    class VerifyingPartialClassDoubleProxy < VerifyingPartialDoubleProxy
+      include PartialClassDoubleProxyMethods
+    end
+
+    # @private
     class VerifyingMethodDouble < MethodDouble
       def initialize(object, method_name, proxy, method_reference)
         super(object, method_name, proxy)
@@ -100,51 +116,55 @@ module RSpec
         VerifyingMessageExpectation
       end
 
-      def add_expectation(*arg)
-        super.tap { |x| x.method_reference = @method_reference }
+      def add_expectation(*args, &block)
+        # explict params necessary for 1.8.7 see #626
+        super(*args, &block).tap { |x| x.method_reference = @method_reference }
+      end
+
+      def add_stub(*args, &block)
+        # explict params necessary for 1.8.7 see #626
+        super(*args, &block).tap { |x| x.method_reference = @method_reference }
       end
 
       def proxy_method_invoked(obj, *args, &block)
-        ensure_arity!(args.length)
+        validate_arguments!(args)
         super
       end
 
     private
 
-      def ensure_arity!(arity)
-        @method_reference.when_defined do |method|
-          calculator = ArityCalculator.new(method)
-          unless calculator.within_range?(arity)
-            raise ArgumentError, "wrong number of arguments (#{arity} for #{method.arity})"
-          end
+      def validate_arguments!(actual_args)
+        @method_reference.with_signature do |signature|
+          verifier = Support::StrictSignatureVerifier.new(signature, actual_args)
+          raise ArgumentError, verifier.error_message unless verifier.valid?
         end
       end
     end
 
-    # @api private
-    #
     # A VerifyingMethodDouble fetches the method to verify against from the
     # original object, using a MethodReference. This works for pure doubles,
     # but when the original object is itself the one being modified we need to
     # collapse the reference and the method double into a single object so that
     # we can access the original pristine method definition.
+    #
+    # @private
     class VerifyingExistingMethodDouble < VerifyingMethodDouble
       def initialize(object, method_name, proxy)
         super(object, method_name, proxy, self)
 
-        @valid_method = object.respond_to?(method_name)
+        @valid_method = object.respond_to?(method_name, true)
 
         # Trigger an eager find of the original method since if we find it any
         # later we end up getting a stubbed method with incorrect arity.
         save_original_method!
       end
 
-      def when_defined
-        yield original_method
+      def with_signature
+        yield Support::MethodSignature.new(original_method)
       end
 
-      def when_unimplemented
-        yield unless @valid_method
+      def unimplemented?
+        !@valid_method
       end
     end
   end

data/rspec-mocks/lib/rspec/mocks/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Mocks
+    # Version information for RSpec mocks.
+    module Version
+      # Version of RSpec mocks currently in use in SemVer format.
+      STRING = '3.1.3'
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support 'caller_filter'
+RSpec::Support.require_rspec_support 'warnings'
+RSpec::Support.require_rspec_support 'ruby_features'
+
+RSpec::Support.define_optimized_require_for_rspec(:mocks) { |f| require_relative f }
+
+%w[
+  instance_method_stasher
+  method_double
+  argument_matchers
+  example_methods
+  proxy
+  test_double
+  argument_list_matcher
+  message_expectation
+  order_group
+  error_generator
+  space
+  mutate_const
+  targets
+  syntax
+  configuration
+  verifying_double
+  version
+].each { |name| RSpec::Support.require_rspec_mocks name }
+
+# Share the top-level RSpec namespace, because we are a core supported
+# extension.
+module RSpec
+  # Contains top-level utility methods. While this contains a few
+  # public methods, these are not generally meant to be called from
+  # a test or example. They exist primarily for integration with
+  # test frameworks (such as rspec-core).
+  module Mocks
+    # Performs per-test/example setup. This should be called before
+    # an test or example begins.
+    def self.setup
+      @space_stack << (@space = space.new_scope)
+    end
+
+    # Verifies any message expectations that were set during the
+    # test or example. This should be called at the end of an example.
+    def self.verify
+      space.verify_all
+    end
+
+    # Cleans up all test double state (including any methods that were
+    # redefined on partial doubles). This _must_ be called after
+    # each example, even if an error was raised during the example.
+    def self.teardown
+      space.reset_all
+      @space_stack.pop
+      @space = @space_stack.last || @root_space
+    end
+
+    # Adds an allowance (stub) on `subject`
+    #
+    # @param subject the subject to which the message will be added
+    # @param message a symbol, representing the message that will be
+    #                added.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the allowance
+    #
+    # @example Defines the implementation of `foo` on `bar`, using the passed block
+    #   x = 0
+    #   RSpec::Mocks.allow_message(bar, :foo) { x += 1 }
+    def self.allow_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_stub(message, opts, &block)
+    end
+
+    # Sets a message expectation on `subject`.
+    # @param subject the subject on which the message will be expected
+    # @param message a symbol, representing the message that will be
+    #                expected.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the expectation
+    #
+    # @example Expect the message `foo` to receive `bar`, then call it
+    #   RSpec::Mocks.expect_message(bar, :foo)
+    #   bar.foo
+    def self.expect_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_message_expectation(message, opts, &block)
+    end
+
+    # Call the passed block and verify mocks after it has executed. This allows
+    # mock usage in arbitrary places, such as a `before(:all)` hook.
+    def self.with_temporary_scope
+      setup
+
+      begin
+        yield
+        verify
+      ensure
+        teardown
+      end
+    end
+
+    class << self
+      # @private
+      attr_reader :space
+    end
+    @space_stack = []
+    @root_space  = @space = RSpec::Mocks::RootSpace.new
+
+    # @private
+    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
+
+    # To speed up boot time a bit, delay loading optional or rarely
+    # used features until their first use.
+    autoload :AnyInstance,      "rspec/mocks/any_instance"
+    autoload :ExpectChain,      "rspec/mocks/message_chain"
+    autoload :StubChain,        "rspec/mocks/message_chain"
+    autoload :MarshalExtension, "rspec/mocks/marshal_extension"
+
+    # Namespace for mock-related matchers.
+    module Matchers
+      autoload :HaveReceived,        "rspec/mocks/matchers/have_received"
+      autoload :Receive,             "rspec/mocks/matchers/receive"
+      autoload :ReceiveMessageChain, "rspec/mocks/matchers/receive_message_chain"
+      autoload :ReceiveMessages,     "rspec/mocks/matchers/receive_messages"
+    end
+  end
+end