opal-rspec-cj 0.4.4

data/vendor_lib/rspec/mocks/arity_calculator.rb

@@ -0,0 +1,66 @@
+module RSpec
+  module Mocks
+
+    # Figures out the valid arity range for a method. Surprisingly non-trivial.
+    class ArityCalculator
+
+      def initialize(method)
+        @method = method
+      end
+
+      # @api private
+      def within_range?(actual)
+        min_arity <= actual && actual <= max_arity
+      end
+
+      # @api private
+      def range_description
+        return min_arity.to_s if min_arity == max_arity
+        return "#{min_arity} or more" if max_arity == INFINITY
+        "#{min_arity} to #{max_arity}"
+      end
+
+      private
+
+      def method
+        @method
+      end
+
+      # @api private
+      def self.supports_optional_and_splat_args?
+        Method.method_defined?(:parameters)
+      end
+
+      def min_arity
+        return method.arity if method.arity >= 0
+        # `~` inverts the one's complement and gives us the number of
+        # required arguments.
+        ~method.arity
+      end
+
+      if supports_optional_and_splat_args?
+        def max_arity
+          params = method.parameters
+          if params.any? {|(type, _)| type == :rest }
+            # Method takes a splat argument
+            return INFINITY
+          else
+            params.count {|(type, _)| type != :block }
+          end
+        end
+      else
+        def max_arity
+          # On 1.8, Method#parameters does not exist.  There is no way to
+          # distinguish between default and splat args, so there is no way to
+          # have it work correctly for both default and splat args, as far as I
+          # can tell. The best we can do is consider it INFINITY (to be
+          # tolerant of splat args).
+          method.arity < 0 ? INFINITY : method.arity
+        end
+      end
+
+      INFINITY = 1/0.0
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/configuration.rb

@@ -0,0 +1,111 @@
+module RSpec
+  module Mocks
+    # Provides configuration options for rspec-mocks.
+    class Configuration
+
+      def initialize
+        @yield_receiver_to_any_instance_implementation_blocks = true
+        @verify_doubled_constant_names = false
+        @transfer_nested_constants = false
+        @verify_partial_doubles = false
+      end
+
+      def yield_receiver_to_any_instance_implementation_blocks?
+        @yield_receiver_to_any_instance_implementation_blocks
+      end
+
+      def yield_receiver_to_any_instance_implementation_blocks=(arg)
+        @yield_receiver_to_any_instance_implementation_blocks = arg
+      end
+
+      # Adds `stub` and `should_receive` to the given
+      # modules or classes. This is usually only necessary
+      # if you application uses some proxy classes that
+      # "strip themselves down" to a bare minimum set of
+      # methods and remove `stub` and `should_receive` in
+      # the process.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.add_stub_and_should_receive_to Delegator
+      #     end
+      #   end
+      #
+      def add_stub_and_should_receive_to(*modules)
+        modules.each do |mod|
+          Syntax.enable_should(mod)
+        end
+      end
+
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Syntax.enable_expect
+        else
+          Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Syntax.enable_should
+        else
+          Syntax.disable_should
+        end
+      end
+
+      def syntax
+        syntaxes = []
+        syntaxes << :should  if Syntax.should_enabled?
+        syntaxes << :expect if Syntax.expect_enabled?
+        syntaxes
+      end
+
+      def verify_doubled_constant_names?
+        !!@verify_doubled_constant_names
+      end
+
+      # When this is set to true, an error will be raised when
+      # `instance_double` or `class_double` is given the name of an undefined
+      # constant. You probably only want to set this when running your entire
+      # test suite, with all production code loaded. Setting this for an
+      # isolated unit test will prevent you from being able to isolate it!
+      def verify_doubled_constant_names=(val)
+        @verify_doubled_constant_names = val
+      end
+
+      def transfer_nested_constants?
+        !!@transfer_nested_constants
+      end
+
+      # Sets the default for the `transfer_nested_constants` option when
+      # stubbing constants.
+      def transfer_nested_constants=(val)
+        @transfer_nested_constants = val
+      end
+
+      # When set to true, partial mocks will be verified the same as object
+      # doubles. Any stubs will have their arity checked against the original
+      # method, and methods that do not exist cannot be stubbed.
+      def verify_partial_doubles=(val)
+        @verify_partial_doubles = !!val
+      end
+
+      def verify_partial_doubles?
+        @verify_partial_doubles
+      end
+
+      # @api private
+      # Resets the configured syntax to the default.
+      def reset_syntaxes_to_default
+        self.syntax = [:should, :expect]
+        RSpec::Mocks::Syntax.warn_about_should!
+      end
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    configuration.reset_syntaxes_to_default
+  end
+end

data/vendor_lib/rspec/mocks/error_generator.rb

@@ -0,0 +1,203 @@
+module RSpec
+  module Mocks
+    # @private
+    class ErrorGenerator
+      attr_writer :opts
+
+      def initialize(target, name)
+        @target = target
+        @name = name
+      end
+
+      # @private
+      def opts
+        @opts ||= {}
+      end
+
+      # @private
+      def raise_unexpected_message_error(message, *args)
+        __raise "#{intro} received unexpected message :#{message}#{arg_message(*args)}"
+      end
+
+      # @private
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_missing_default_stub_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = format_received_args(*args)
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}\n Please stub a default value first if message might be received with other args as well. \n"
+      end
+
+      # @private
+      def raise_similar_message_args_error(expectation, *args_for_multiple_calls)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args_for_multiple_calls.collect {|a| format_received_args(*a)}.join(", ")
+        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+
+      # @private
+      def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, *args)
+        expected_part = expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        received_part = received_part_of_expectation_error(actual_received_count, *args)
+        __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
+      end
+
+      # @private
+      def raise_unimplemented_error(doubled_module, method_name)
+        __raise "%s does not implement:\n  %s" % [
+          doubled_module.description,
+          method_name
+        ]
+      end
+
+      # @private
+      def raise_arity_error(calculator, actual)
+        __raise "Wrong number of arguments. Expected %s, got %s." % [
+          calculator.range_description,
+          actual
+        ]
+      end
+
+      # @private
+      def received_part_of_expectation_error(actual_received_count, *args)
+        "received: #{count_message(actual_received_count)}" +
+          method_call_args_description(args)
+      end
+
+      # @private
+      def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        "expected: #{count_message(expected_received_count, expectation_count_type)}" +
+          method_call_args_description(argument_list_matcher.expected_args)
+      end
+
+      # @private
+      def method_call_args_description(args)
+        case args.first
+          when ArgumentMatchers::AnyArgsMatcher
+            return " with any arguments"
+          when ArgumentMatchers::NoArgsMatcher
+            return " with no arguments"
+        end
+
+        if args.length > 0
+          " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+        else
+          ""
+        end
+      end
+
+      # @private
+      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+        "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
+      end
+
+      # @private
+      def raise_out_of_order_error(message)
+        __raise "#{intro} received :#{message} out of order"
+      end
+
+      # @private
+      def raise_block_failed_error(message, detail)
+        __raise "#{intro} received :#{message} but passed block failed with: #{detail}"
+      end
+
+      # @private
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+
+      # @private
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+
+      # @private
+      def raise_only_valid_on_a_partial_mock(method)
+        __raise "#{intro} is a pure mock object. `#{method}` is only " +
+                "available on a partial mock object."
+      end
+
+      # @private
+      def raise_expectation_on_unstubbed_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has not been stubbed."
+      end
+
+      # @private
+      def raise_expectation_on_mocked_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has been mocked instead of stubbed."
+      end
+
+      def self.raise_double_negation_error(wrapped_expression)
+        raise "Isn't life confusing enough? You've already set a " +
+              "negative message expectation and now you are trying to " +
+              "negate it again with `never`. What does an expression like " +
+              "`#{wrapped_expression}.not_to receive(:msg).never` even mean?"
+      end
+
+      private
+
+      def intro
+        if @name
+          "Double #{@name.inspect}"
+        elsif TestDouble === @target
+          "Double"
+        elsif Class === @target
+          "<#{@target.inspect} (class)>"
+        elsif @target
+          @target
+        else
+          "nil"
+        end
+      end
+
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+      end
+
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect {|arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
+      end
+
+      def arg_has_valid_description(arg)
+        return false unless arg.respond_to?(:description)
+
+        !arg.description.nil? && !arg.description.empty?
+      end
+
+      def format_received_args(*args)
+        args.empty? ? "(no args)" : "(" + received_arg_list(*args) + ")"
+      end
+
+      def received_arg_list(*args)
+        args.collect(&:inspect).join(", ")
+      end
+
+      def count_message(count, expectation_count_type=nil)
+        return "at least #{pretty_print(count.abs)}" if count < 0 || expectation_count_type == :at_least
+        return "at most #{pretty_print(count)}" if expectation_count_type == :at_most
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        "#{count} time#{count == 1 ? '' : 's'}"
+      end
+
+    end
+  end
+end

data/vendor_lib/rspec/mocks/errors.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Mocks
+    # @private
+    class MockExpectationError < Exception
+    end
+
+    # @private
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/example_methods.rb

@@ -0,0 +1,201 @@
+require 'rspec/mocks/object_reference'
+
+module RSpec
+  module Mocks
+    module ExampleMethods
+      include RSpec::Mocks::ArgumentMatchers
+
+      # @overload double()
+      # @overload double(name)
+      # @overload double(stubs)
+      # @overload double(name, stubs)
+      # @param name [String/Symbol] (optional) used in
+      #   clarify intent
+      # @param stubs (Hash) (optional) hash of message/return-value pairs
+      # @return (Mock)
+      #
+      # Constructs an instance of [RSpec::Mocks::Mock](RSpec::Mocks::Mock) configured
+      # with an optional name, used for reporting in failure messages, and an optional
+      # hash of message/return-value pairs.
+      #
+      # @example
+      #
+      #   book = double("book", :title => "The RSpec Book")
+      #   book.title #=> "The RSpec Book"
+      #
+      #   card = double("card", :suit => "Spades", :rank => "A")
+      #   card.suit  #=> "Spades"
+      #   card.rank  #=> "A"
+      #
+      def double(*args)
+        declare_double(Mock, *args)
+      end
+
+      # @overload instance_double(doubled_class)
+      # @overload instance_double(doubled_class, stubs)
+      # @param doubled_class [String, Class]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return InstanceVerifyingDouble
+      #
+      # Constructs a test double against a specific class. If the given class
+      # name has been loaded, only instance methods defined on the class are
+      # allowed to be stubbed. In all other ways it behaves like a
+      # [double](double).
+      def instance_double(doubled_class, *args)
+        ref = ObjectReference.for(doubled_class)
+        declare_verifying_double(InstanceVerifyingDouble, ref, *args)
+      end
+
+      # @overload class_double(doubled_class)
+      # @overload class_double(doubled_class, stubs)
+      # @param doubled_class [String, Module]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return ClassVerifyingDouble
+      #
+      # Constructs a test double against a specific class. If the given class
+      # name has been loaded, only class methods defined on the class are
+      # allowed to be stubbed. In all other ways it behaves like a
+      # [double](double).
+      def class_double(doubled_class, *args)
+        ref = ObjectReference.for(doubled_class)
+        declare_verifying_double(ClassVerifyingDouble, ref, *args)
+      end
+
+      # @overload object_double(object_or_name)
+      # @overload object_double(object_or_name, stubs)
+      # @param object_or_name [String, Object]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return ObjectVerifyingDouble
+      #
+      # Constructs a test double against a specific object. Only the methods
+      # the object responds to are allowed to be stubbed. If a String argument
+      # is provided, it is assumed to reference a constant object which is used
+      # for verification. In all other ways it behaves like a [double](double).
+      def object_double(object_or_name, *args)
+        ref = ObjectReference.for(object_or_name, :allow_direct_object_refs)
+        declare_verifying_double(ObjectVerifyingDouble, ref, *args)
+      end
+
+      # Disables warning messages about expectations being set on nil.
+      #
+      # By default warning messages are issued when expectations are set on
+      # nil.  This is to prevent false-positives and to catch potential bugs
+      # early on.
+      def allow_message_expectations_on_nil
+        RSpec::Mocks.space.proxy_for(nil).warn_about_expectations = false
+      end
+
+      # Stubs the named constant with the given value.
+      # Like method stubs, the constant will be restored
+      # to its original value (or lack of one, if it was
+      # undefined) when the example completes.
+      #
+      # @param constant_name [String] The fully qualified name of the constant. The current
+      #   constant scoping at the point of call is not considered.
+      # @param value [Object] The value to make the constant refer to. When the
+      #   example completes, the constant will be restored to its prior state.
+      # @param options [Hash] Stubbing options.
+      # @option options :transfer_nested_constants [Boolean, Array<Symbol>] Determines
+      #   what nested constants, if any, will be transferred from the original value
+      #   of the constant to the new value of the constant. This only works if both
+      #   the original and new values are modules (or classes).
+      # @return [Object] the stubbed value of the constant
+      #
+      # @example
+      #
+      #   stub_const("MyClass", Class.new) # => Replaces (or defines) MyClass with a new class object.
+      #   stub_const("SomeModel::PER_PAGE", 5) # => Sets SomeModel::PER_PAGE to 5.
+      #
+      #   class CardDeck
+      #     SUITS = [:Spades, :Diamonds, :Clubs, :Hearts]
+      #     NUM_CARDS = 52
+      #   end
+      #
+      #   stub_const("CardDeck", Class.new)
+      #   CardDeck::SUITS # => uninitialized constant error
+      #   CardDeck::NUM_CARDS # => uninitialized constant error
+      #
+      #   stub_const("CardDeck", Class.new, :transfer_nested_constants => true)
+      #   CardDeck::SUITS # => our suits array
+      #   CardDeck::NUM_CARDS # => 52
+      #
+      #   stub_const("CardDeck", Class.new, :transfer_nested_constants => [:SUITS])
+      #   CardDeck::SUITS # => our suits array
+      #   CardDeck::NUM_CARDS # => uninitialized constant error
+      def stub_const(constant_name, value, options = {})
+        ConstantMutator.stub(constant_name, value, options)
+      end
+
+      # Hides the named constant with the given value. The constant will be
+      # undefined for the duration of the test.
+      #
+      # Like method stubs, the constant will be restored to its original value
+      # when the example completes.
+      #
+      # @param constant_name [String] The fully qualified name of the constant.
+      #   The current constant scoping at the point of call is not considered.
+      #
+      # @example
+      #
+      #   hide_const("MyClass") # => MyClass is now an undefined constant
+      def hide_const(constant_name)
+        ConstantMutator.hide(constant_name)
+      end
+
+      # Verifies that the given object received the expected message during the
+      # course of the test. The method must have previously been stubbed in
+      # order for messages to be verified.
+      #
+      # Stubbing and verifying messages received in this way implements the
+      # Test Spy pattern.
+      #
+      # @param method_name [Symbol] name of the method expected to have been
+      #   called.
+      #
+      # @example
+      #
+      #   invitation = double('invitation', accept: true)
+      #   user.accept_invitation(invitation)
+      #   expect(invitation).to have_received(:accept)
+      #
+      #   # You can also use most message expectations:
+      #   expect(invitation).to have_received(:accept).with(mailer).once
+      def have_received(method_name, &block)
+        Matchers::HaveReceived.new(method_name, &block)
+      end
+
+      def self.included(klass)
+        klass.class_exec do
+          # This gets mixed in so that if `RSpec::Matchers` is included in
+          # `klass` later, it's definition of `expect` will take precedence.
+          include ExpectHost unless method_defined?(:expect)
+        end
+      end
+
+    private
+
+      def declare_verifying_double(type, ref, *args)
+        if RSpec::Mocks.configuration.verify_doubled_constant_names? &&
+          !ref.defined?
+
+          raise NameError,
+            "#{ref.name} is not a defined constant. " +
+            "Perhaps you misspelt it? " +
+            "Disable check with verify_doubled_constant_names configuration option."
+        end
+
+        declare_double(type, ref, *args)
+      end
+
+      def declare_double(type, *args)
+        args << {} unless Hash === args.last
+        type.new(*args)
+      end
+
+      # This module exists to host the `expect` method for cases where
+      # rspec-mocks is used w/o rspec-expectations.
+      module ExpectHost
+      end
+    end
+  end
+end