opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/mocks/argument_list_matcher.rb

@@ -1,104 +0,0 @@
-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

@@ -1,264 +0,0 @@
-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

data/vendor_lib/rspec/mocks/arity_calculator.rb

@@ -1,66 +0,0 @@
-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/errors.rb

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

data/vendor_lib/rspec/mocks/example_methods.rb

@@ -1,201 +0,0 @@
-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

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

@@ -1,17 +0,0 @@
-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

@@ -1,36 +0,0 @@
-# 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'