dxruby_rp5 0.0.1

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

@@ -0,0 +1,349 @@
+module RSpec
+  module Mocks
+    # @api private
+    # Provides methods for enabling and disabling the available syntaxes
+    # provided by rspec-mocks.
+    module Syntax
+      # @api private
+      #
+      # Common stubbing logic for both `stub` and `stub!`. This used to
+      # live in `stub`, and `stub!` delegated to `stub`, but we discovered
+      # that `stub!` was delegating to `RSpec::Mocks::ExampleMethods#stub`
+      # (which declares a test double) when called with an implicit receiver,
+      # which was a regression in 2.14.0.
+      def self.stub_object(object, message_or_hash, opts = {}, &block)
+        if ::Hash === message_or_hash
+          message_or_hash.each {|message, value| stub_object(object, message).and_return value }
+        else
+          opts[:expected_from] = caller(1)[1]
+          ::RSpec::Mocks.allow_message(object, message_or_hash, opts, &block)
+        end
+      end
+
+      # @api private
+      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.enable_should(syntax_host = default_should_syntax_host)
+        return if should_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          def should_receive(message, opts={}, &block)
+            opts[:expected_from] ||= caller(1)[0]
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block)
+          end
+
+          def should_not_receive(message, &block)
+            opts = {:expected_from => caller(1)[0]}
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block).never
+          end
+
+          def stub(message_or_hash, opts={}, &block)
+            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
+          end
+
+          def unstub(message)
+            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
+          end
+
+          def stub!(message_or_hash, opts={}, &block)
+            ::RSpec.deprecate "stub!", :replacement => "stub"
+            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
+          end
+
+          def unstub!(message)
+            ::RSpec.deprecate "unstub!", :replacement => "unstub"
+            unstub(message)
+          end
+
+          def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
+          end
+
+          def as_null_object
+            @_null_object = true
+            ::RSpec::Mocks.proxy_for(self).as_null_object
+          end
+
+          def null_object?
+            defined?(@_null_object)
+          end
+
+          def received_message?(message, *args, &block)
+            ::RSpec::Mocks.proxy_for(self).received_message?(message, *args, &block)
+          end
+
+          unless Class.respond_to? :any_instance
+            Class.class_eval do
+              def any_instance
+                ::RSpec::Mocks.any_instance_recorder_for(self)
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.disable_should(syntax_host = default_should_syntax_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          undef should_receive
+          undef should_not_receive
+          undef stub
+          undef unstub
+          undef stub!
+          undef unstub!
+          undef stub_chain
+          undef as_null_object
+          undef null_object?
+          undef received_message?
+        end
+
+        Class.class_eval do
+          undef any_instance
+        end
+      end
+
+      # @api private
+      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          def receive(method_name, &block)
+            Matchers::Receive.new(method_name, block)
+          end
+
+          def allow(target)
+            AllowanceTarget.new(target)
+          end
+
+          def expect_any_instance_of(klass)
+            AnyInstanceExpectationTarget.new(klass)
+          end
+
+          def allow_any_instance_of(klass)
+            AnyInstanceAllowanceTarget.new(klass)
+          end
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+          def expect(target)
+            ExpectationTarget.new(target)
+          end
+        end
+      end
+
+      # @api private
+      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.class_eval do
+          undef receive
+          undef allow
+          undef expect_any_instance_of
+          undef allow_any_instance_of
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+          undef expect
+        end
+      end
+
+      # @api private
+      # Indicates whether or not the should syntax is enabled.
+      def self.should_enabled?(syntax_host = default_should_syntax_host)
+        syntax_host.method_defined?(:should_receive)
+      end
+
+      # @api private
+      # Indicates whether or not the expect syntax is enabled.
+      def self.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods)
+        syntax_host.method_defined?(:allow)
+      end
+
+      # @api private
+      # Determines where the methods like `should_receive`, and `stub` are added.
+      def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
+        # On 1.8.7, Object.ancestors.last == Kernel but
+        # things blow up if we include `RSpec::Mocks::Methods`
+        # into Kernel...not sure why.
+        return Object unless defined?(::BasicObject)
+
+        # MacRuby has BasicObject but it's not the root class.
+        return Object unless Object.ancestors.last == ::BasicObject
+
+        ::BasicObject
+      end
+
+      # @method should_receive
+      # Sets an expectation that this object should receive a message before
+      # the end of the example.
+      #
+      # @example
+      #
+      #     logger = double('logger')
+      #     thing_that_logs = ThingThatLogs.new(logger)
+      #     logger.should_receive(:log)
+      #     thing_that_logs.do_something_that_logs_a_message
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method should_not_receive
+      # Sets and expectation that this object should _not_ receive a message
+      # during this example.
+
+      # @method stub
+      # Tells the object to respond to the message with the specified value.
+      #
+      # @example
+      #
+      #     counter.stub(:count).and_return(37)
+      #     counter.stub(:count => 37)
+      #     counter.stub(:count) { 37 }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method unstub
+      # Removes a stub. On a double, the object will no longer respond to
+      # `message`. On a real object, the original method (if it exists) is
+      # restored.
+      #
+      # This is rarely used, but can be useful when a stub is set up during a
+      # shared `before` hook for the common case, but you want to replace it
+      # for a special case.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method stub_chain
+      # @overload stub_chain(method1, method2)
+      # @overload stub_chain("method1.method2")
+      # @overload stub_chain(method1, method_to_value_hash)
+      #
+      # Stubs a chain of methods.
+      #
+      # ## Warning:
+      #
+      # Chains can be arbitrarily long, which makes it quite painless to
+      # violate the Law of Demeter in violent ways, so you should consider any
+      # use of `stub_chain` a code smell. Even though not all code smells
+      # indicate real problems (think fluent interfaces), `stub_chain` still
+      # results in brittle examples.  For example, if you write
+      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
+      # implementation calls `foo.baz.bar`, the stub will not work.
+      #
+      # @example
+      #
+      #     double.stub_chain("foo.bar") { :baz }
+      #     double.stub_chain(:foo, :bar => :baz)
+      #     double.stub_chain(:foo, :bar) { :baz }
+      #
+      #     # Given any of ^^ these three forms ^^:
+      #     double.foo.bar # => :baz
+      #
+      #     # Common use in Rails/ActiveRecord:
+      #     Article.stub_chain("recent.published") { [Article.new] }
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method as_null_object
+      # Tells the object to respond to all messages. If specific stub values
+      # are declared, they'll work as expected. If not, the receiver is
+      # returned.
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method null_object?
+      # Returns true if this object has received `as_null_object`
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method any_instance
+      # 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]
+      #
+      # @note This is only available when you have enabled the `should` syntax.
+
+      # @method expect
+      # Used to wrap an object in preparation for setting a mock expectation
+      # on it.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This method is usually provided by rspec-expectations, unless
+      #   you are using rspec-mocks w/o rspec-expectations, in which case it
+      #   is only made available if you enable the `expect` syntax.
+
+      # @method allow
+      # Used to wrap an object in preparation for stubbing a method
+      # on it.
+      #
+      # @example
+      #
+      #   allow(dbl).to receive(:foo).with(5).and_return(:return_value)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method expect_any_instance_of
+      # Used to wrap a class in preparation for setting a mock expectation
+      # on instances of it.
+      #
+      # @example
+      #
+      #   expect_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method allow_any_instance_of
+      # Used to wrap a class in preparation for stubbing a method
+      # on instances of it.
+      #
+      # @example
+      #
+      #   allow_any_instance_of(MyClass).to receive(:foo)
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+
+      # @method receive
+      # Used to specify a message that you expect or allow an object
+      # to receive. The object returned by `receive` supports the same
+      # fluent interface that `should_receive` and `stub` have always
+      # supported, allowing you to constrain the arguments or number of
+      # times, and configure how the object should respond to the message.
+      #
+      # @example
+      #
+      #   expect(obj).to receive(:hello).with("world").exactly(3).times
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
+    end
+  end
+end
+

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

@@ -0,0 +1,69 @@
+module RSpec
+  module Mocks
+    UnsupportedMatcherError  = Class.new(StandardError)
+    NegationUnsupportedError = Class.new(StandardError)
+
+    class TargetBase
+      def initialize(target)
+        @target = target
+      end
+
+      def self.delegate_to(matcher_method, options = {})
+        method_name = options.fetch(:from) { :to }
+        class_eval(<<-RUBY)
+        def #{method_name}(matcher, &block)
+          unless Matchers::Receive === matcher
+            raise UnsupportedMatcherError, "only the `receive` matcher is supported " +
+              "with `\#{expression}(...).\#{#{method_name.inspect}}`, but you have provided: \#{matcher}"
+          end
+
+          matcher.__send__(#{matcher_method.inspect}, @target, &block)
+        end
+        RUBY
+      end
+
+      def self.disallow_negation(method)
+        define_method method do |*args|
+          raise NegationUnsupportedError,
+            "`#{expression}(...).#{method} receive` is not supported since it " +
+            "doesn't really make sense. What would it even mean?"
+        end
+      end
+
+    private
+
+      def expression
+        self.class::EXPRESSION
+      end
+    end
+
+    class AllowanceTarget < TargetBase
+      EXPRESSION = :allow
+      delegate_to :setup_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    class ExpectationTarget < TargetBase
+      EXPRESSION = :expect
+      delegate_to :setup_expectation
+      delegate_to :setup_negative_expectation, :from => :not_to
+      delegate_to :setup_negative_expectation, :from => :to_not
+    end
+
+    class AnyInstanceAllowanceTarget < TargetBase
+      EXPRESSION = :expect_any_instance_of
+      delegate_to :setup_any_instance_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    class AnyInstanceExpectationTarget < TargetBase
+      EXPRESSION = :expect_any_instance_of
+      delegate_to :setup_any_instance_expectation
+      delegate_to :setup_any_instance_negative_expectation, :from => :not_to
+      delegate_to :setup_any_instance_negative_expectation, :from => :to_not
+    end
+  end
+end
+

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

@@ -0,0 +1,135 @@
+module RSpec
+  module Mocks
+    # Implements the methods needed for a pure test double.  RSpec::Mocks::Mock
+    # includes this module, and it is provided for cases where you want a
+    # pure test double without subclassing RSpec::Mocks::Mock.
+    module TestDouble
+      # Extends the TestDouble module onto the given object and
+      # initializes it as a test double.
+      #
+      # @example
+      #
+      #   module = Module.new
+      #   RSpec::Mocks::TestDouble.extend_onto(module, "MyMixin", :foo => "bar")
+      #   module.foo  #=> "bar"
+      def self.extend_onto(object, name=nil, stubs_and_options={})
+        object.extend self
+        object.send(:__initialize_as_test_double, name, stubs_and_options)
+      end
+
+      # Creates a new test double with a `name` (that will be used in error
+      # messages only)
+      def initialize(name=nil, stubs_and_options={})
+        __initialize_as_test_double(name, stubs_and_options)
+      end
+
+      # Tells the object to respond to all messages. If specific stub values
+      # are declared, they'll work as expected. If not, the receiver is
+      # returned.
+      def as_null_object
+        @__null_object = true
+        __mock_proxy.as_null_object
+      end
+
+      # Returns true if this object has received `as_null_object`
+      def null_object?
+        @__null_object
+      end
+
+      # This allows for comparing the mock to other objects that proxy such as
+      # ActiveRecords belongs_to proxy objects. By making the other object run
+      # the comparison, we're sure the call gets delegated to the proxy
+      # target.
+      def ==(other)
+        other == __mock_proxy
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+      end
+
+      # @private
+      def to_s
+        inspect.gsub('<','[').gsub('>',']')
+      end
+
+      alias_method :to_str, :to_s
+
+      # @private
+      def respond_to?(message, incl_private=false)
+        __mock_proxy.null_object? ? true : super
+      end
+
+      # @private
+      def __build_mock_proxy
+        proxy = Proxy.new(self, @name, @options || {})
+        proxy.as_null_object if null_object?
+        proxy
+      end
+
+    private
+
+      def __initialize_as_test_double(name=nil, stubs_and_options={})
+        @__null_object = false
+
+        if name.is_a?(Hash) && stubs_and_options.empty?
+          stubs_and_options = name
+          @name = nil
+        else
+          @name = name
+        end
+        @options = extract_options(stubs_and_options)
+        assign_stubs(stubs_and_options)
+      end
+
+      def method_missing(message, *args, &block)
+        if __mock_proxy.null_object?
+          case message
+          when :to_int        then return 0
+          when :to_a, :to_ary then return nil
+          end
+        end
+        __mock_proxy.record_message_received(message, *args, &block)
+
+        begin
+          __mock_proxy.null_object? ? self : super
+        rescue NameError
+          # Required wrapping doubles in an Array on Ruby 1.9.2
+          raise NoMethodError if [:to_a, :to_ary].include? message
+          __mock_proxy.raise_unexpected_message_error(message, *args)
+        end
+      end
+
+      def extract_options(stubs_and_options)
+        if stubs_and_options[:null_object]
+          @null_object = stubs_and_options.delete(:null_object)
+          RSpec.deprecate("double('name', :null_object => true)", :replacement => "double('name').as_null_object")
+        end
+        options = {}
+        extract_option(stubs_and_options, options, :__declared_as, 'Mock')
+        options
+      end
+
+      def extract_option(source, target, key, default=nil)
+        if source[key]
+          target[key] = source.delete(key)
+        elsif default
+          target[key] = default
+        end
+      end
+
+      def assign_stubs(stubs)
+        stubs.each_pair do |message, response|
+          Mocks.allow_message(self, message).and_return(response)
+        end
+      end
+
+    private
+
+      def __mock_proxy
+        ::RSpec::Mocks.proxy_for(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module RSpec
+  module Mocks
+    module Version
+      STRING = '2.14.4'
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require 'rspec/mocks/framework'
+require 'rspec/mocks/version'
+
+module RSpec
+
+  module Mocks
+    class << self
+      attr_accessor :space
+
+      def setup(host)
+        (class << host; self; end).class_eval do
+          include RSpec::Mocks::ExampleMethods
+        end
+        self.space ||= RSpec::Mocks::Space.new
+      end
+
+      def verify
+        space.verify_all
+      end
+
+      def teardown
+        space.reset_all
+      end
+
+      def proxy_for(object)
+        space.proxy_for(object)
+      end
+
+      def proxies_of(klass)
+        space.proxies_of(klass)
+      end
+
+      def any_instance_recorder_for(klass)
+        space.any_instance_recorder_for(klass)
+      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
+      # @param block 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 allow_message(subject, message, opts={}, &block)
+        orig_caller = opts.fetch(:expected_from) { caller(1)[0] }
+        ::RSpec::Mocks.proxy_for(subject).
+          add_stub(orig_caller, message.to_sym, 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
+      # @param block 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 expect_message(subject, message, opts={}, &block)
+        orig_caller = opts.fetch(:expected_from) { caller(1)[0] }
+        ::RSpec::Mocks.proxy_for(subject).
+          add_message_expectation(orig_caller, message.to_sym, opts, &block)
+      end
+
+      # @api private
+      KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
+
+      # @api private
+      # Used internally to get a method handle for a particular object
+      # and method name.
+      #
+      # Includes handling for a few special cases:
+      #
+      #   - Objects that redefine #method (e.g. an HTTPRequest struct)
+      #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
+      def method_handle_for(object, method_name)
+        if ::Kernel === object
+          KERNEL_METHOD_METHOD.bind(object).call(method_name)
+        else
+          object.method(method_name)
+        end
+      end
+    end
+
+    # @private
+    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
+  end
+end
+

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

@@ -0,0 +1,4 @@
+# For backward compatibility with rspec-1
+require 'rspec/mocks'
+
+RSpec.deprecate "require 'spec/mocks'", :replacement => "require 'rspec/mocks'"