remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,81 @@
+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'
+
+module RSpec
+  module Mocks
+    module AnyInstance
+      # 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]
+      def any_instance
+        RSpec::Mocks::space.add(self)
+        modify_dup_to_remove_mock_proxy_when_invoked
+        __recorder
+      end
+
+      # @private
+      def rspec_verify
+        __recorder.verify
+        super
+      ensure
+        __recorder.stop_all_observation!
+        restore_dup
+        @__recorder = nil
+      end
+
+      # @private
+      def rspec_reset
+        restore_dup
+        __mock_proxy.reset
+      end
+
+      # @private
+      def __recorder
+        @__recorder ||= AnyInstance::Recorder.new(self)
+      end
+
+      private
+      def modify_dup_to_remove_mock_proxy_when_invoked
+        if method_defined?(:dup) and !method_defined?(:__rspec_original_dup)
+          class_eval do
+            def __rspec_dup(*arguments, &block)
+              __remove_mock_proxy
+              __rspec_original_dup(*arguments, &block)
+            end
+
+            alias_method  :__rspec_original_dup, :dup
+            alias_method  :dup, :__rspec_dup
+          end
+        end
+      end
+
+      def restore_dup
+        if method_defined?(:__rspec_original_dup)
+          class_eval do
+            alias_method  :dup, :__rspec_original_dup
+            remove_method :__rspec_original_dup
+            remove_method :__rspec_dup
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/argument_list_matcher.rb

@@ -0,0 +1,93 @@
+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')
+    #
+    # @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 arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+
+      def is_matcher?(obj)
+        !obj.null_object? & obj.respond_to?(:matches?) & [:failure_message_for_should, :failure_message].any? { |m| obj.respond_to?(m) }
+      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
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/argument_matchers.rb

@@ -0,0 +1,238 @@
+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 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 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/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/configuration.rb

@@ -0,0 +1,28 @@
+module RSpec
+  module Mocks
+    # Provides configuration options for rspec-mocks.
+    class Configuration
+      # 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|
+          mod.__send__(:include, RSpec::Mocks::Methods)
+        end
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/error_generator.rb

@@ -0,0 +1,120 @@
+module RSpec
+  module Mocks
+    # @private
+    class ErrorGenerator
+      attr_writer :opts
+
+      def initialize(target, name, options={})
+        @declared_as = options[:__declared_as] || 'Mock'
+        @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_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 = args.collect {|a| format_args(*a)}.join(", ")
+        __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)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args.collect {|a| format_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, actual_received_count, *args)
+        __raise "(#{intro}).#{message}#{format_args(*args)}\n    expected: #{count_message(expected_received_count)}\n    received: #{count_message(actual_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 intro
+        if @name
+          "#{@declared_as} #{@name.inspect}"
+        elsif TestDouble === @target
+          @declared_as
+        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.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
+      end
+
+      def count_message(count)
+        return "at least #{pretty_print(count.abs)}" if count < 0
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        "#{count} time#{count == 1 ? '' : 's'}"
+      end
+
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.12.2/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/bundle/gems/rspec-mocks-2.12.2/lib/rspec/mocks/example_methods.rb

@@ -0,0 +1,120 @@
+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 method/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 method/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"
+      #
+      # @see #mock
+      # @see #stub
+      def double(*args)
+        declare_double('Double', *args)
+      end
+
+      # Effectively an alias for [double](#double-instance_method).
+      def mock(*args)
+        declare_double('Mock', *args)
+      end
+
+      # Effectively an alias for [double](#double-instance_method).
+      def stub(*args)
+        declare_double('Stub', *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
+        Proxy.allow_message_expectations_on_nil
+      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
+
+    private
+
+      def declare_double(declared_as, *args)
+        args << {} unless Hash === args.last
+        args.last[:__declared_as] = declared_as
+        RSpec::Mocks::Mock.new(*args)
+      end
+
+    end
+  end
+end