dxruby_rp5 0.0.1

data/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/error_generator.rb

@@ -0,0 +1,179 @@
+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_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 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)
+        if args.first.is_a?(ArgumentMatchers::AnyArgsMatcher)
+          " with any arguments"
+        elsif args.first.is_a?(ArgumentMatchers::NoArgsMatcher)
+          " with no arguments"
+        elsif 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
+          "#{@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 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/spec/vendor/rspec-mocks-2.14.4/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/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/example_methods.rb

@@ -0,0 +1,156 @@
+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
+
+      # Deprecated: Use [double](#double-instance_method).
+      def mock(*args)
+        RSpec.deprecate "mock", :replacement => "double"
+        declare_double('Mock', *args)
+      end
+
+      # Deprecated: Use [double](#double-instance_method).
+      def stub(*args)
+        RSpec.deprecate "stub", :replacement => "double"
+        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
+        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)
+        Matchers::HaveReceived.new(method_name)
+      end
+
+      def self.included(klass)
+        klass.class_eval 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_double(declared_as, *args)
+        args << {} unless Hash === args.last
+        args.last[:__declared_as] = declared_as
+        RSpec::Mocks::Mock.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/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/extensions/instance_exec.rb

@@ -0,0 +1,34 @@
+module RSpec
+  module Mocks
+    # @private
+    module InstanceExec
+      unless respond_to?(:instance_exec)
+        # @private
+        #
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class of matcher instead of global
+        #   InstanceExecHelper module
+        # - this keeps it scoped to this class only, which is the
+        #   only place we need it
+        # - only necessary for ruby 1.8.6
+        def instance_exec(*args, &block)
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/extensions/marshal.rb

@@ -0,0 +1,17 @@
+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/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/framework.rb

@@ -0,0 +1,34 @@
+# 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/mocks/deprecation'
+require 'rspec/mocks/extensions/instance_exec'
+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/stub_chain'
+require 'rspec/mocks/targets'
+require 'rspec/mocks/syntax'
+require 'rspec/mocks/configuration'

data/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/instance_method_stasher.rb

@@ -0,0 +1,94 @@
+module RSpec
+  module Mocks
+    # @private
+    class InstanceMethodStasher
+      def initialize(klass, method)
+        @klass = klass
+        @method = method
+
+        @method_is_stashed = false
+      end
+
+      # @private
+      def method_is_stashed?
+        @method_is_stashed
+      end
+
+      # @private
+      def stash
+        return if !method_defined_directly_on_klass? || @method_is_stashed
+
+        @klass.__send__(:alias_method, stashed_method_name, @method)
+        @method_is_stashed = true
+      end
+
+      private
+
+      # @private
+      def method_defined_directly_on_klass?
+        method_defined_on_klass? && method_owned_by_klass?
+      end
+
+      # @private
+      def method_defined_on_klass?(klass = @klass)
+        klass.method_defined?(@method) || klass.private_method_defined?(@method)
+      end
+
+      if ::UnboundMethod.method_defined?(:owner)
+        # @private
+        def method_owned_by_klass?
+          owner = @klass.instance_method(@method).owner
+
+          # On Ruby 2.0.0+ the owner of a method on a class which has been
+          # `prepend`ed may actually be an instance, e.g.
+          # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
+          owner = owner.class unless owner.is_a? Class
+
+          # On 1.8 (and some 1.9s -- e.g. rubinius) aliased methods
+          # can report the wrong owner. Example:
+          # class MyClass
+          #   class << self
+          #     alias alternate_new new
+          #   end
+          # end
+          #
+          # MyClass.owner(:alternate_new) returns `Class` on 1.8,
+          # but we need to consider the owner to be `MyClass` because
+          # it is not actually available on `Class` but is on `MyClass`.
+          # Hence, we verify that the owner actually has the method defined.
+          # If the given owner does not have the method defined, we assume
+          # that the method is actually owned by @klass.
+          owner == @klass || !(method_defined_on_klass?(owner))
+        end
+      else
+        # @private
+        def method_owned_by_klass?
+          # On 1.8.6, which does not support Method#owner, we have no choice but
+          # to assume it's defined on the klass even if it may be defined on
+          # a superclass.
+          true
+        end
+      end
+
+      public
+
+      # @private
+      def stashed_method_name
+        "obfuscated_by_rspec_mocks__#{@method}"
+      end
+
+      # @private
+      def restore
+        return unless @method_is_stashed
+
+        if @klass.__send__(:method_defined?, @method)
+          @klass.__send__(:undef_method, @method)
+        end
+        @klass.__send__(:alias_method, @method, stashed_method_name)
+        @klass.__send__(:remove_method, stashed_method_name)
+        @method_is_stashed = false
+      end
+    end
+  end
+end
+

data/spec/vendor/rspec-mocks-2.14.4/lib/rspec/mocks/matchers/have_received.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class HaveReceived
+        COUNT_CONSTRAINTS = %w(exactly at_least at_most times once twice)
+        ARGS_CONSTRAINTS = %w(with)
+        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS
+
+        def initialize(method_name)
+          @method_name = method_name
+          @constraints = []
+          @subject = nil
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @expectation = expect
+          expected_messages_received?
+        end
+
+        def does_not_match?(subject)
+          @subject = subject
+          ensure_count_unconstrained
+          @expectation = expect.never
+          expected_messages_received?
+        end
+
+        def failure_message
+          generate_failure_message
+        end
+
+        def negative_failure_message
+          generate_failure_message
+        end
+
+        def description
+          expect.description
+        end
+
+        CONSTRAINTS.each do |expectation|
+          define_method expectation do |*args|
+            @constraints << [expectation, *args]
+            self
+          end
+        end
+
+        private
+
+        def expect
+          expectation = mock_proxy.build_expectation(@method_name)
+          apply_constraints_to expectation
+          expectation
+        end
+
+        def apply_constraints_to(expectation)
+          @constraints.each do |constraint|
+            expectation.send(*constraint)
+          end
+        end
+
+        def ensure_count_unconstrained
+          if count_constraint
+            raise RSpec::Mocks::MockExpectationError,
+              "can't use #{count_constraint} when negative"
+          end
+        end
+
+        def count_constraint
+          @constraints.map(&:first).detect do |constraint|
+            COUNT_CONSTRAINTS.include?(constraint)
+          end
+        end
+
+        def generate_failure_message
+          mock_proxy.check_for_unexpected_arguments(@expectation)
+          @expectation.generate_error
+        rescue RSpec::Mocks::MockExpectationError => error
+          error.message
+        end
+
+        def expected_messages_received?
+          mock_proxy.replay_received_message_on @expectation
+          @expectation.expected_messages_received?
+        end
+
+        def mock_proxy
+          RSpec::Mocks.proxy_for(@subject)
+        end
+      end
+    end
+  end
+end
+