dxruby_rp5 0.0.1

data/spec/vendor/rspec-mocks-2.14.4/features/mutating_constants/stub_defined_constant.feature

@@ -0,0 +1,79 @@
+Feature: Stub Defined Constant
+
+  Use `stub_const` to stub constants. When the constant is already defined,
+  the stubbed value will replace the original value for the duration of the
+  example.
+
+  Scenario: Stub top-level constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      FOO = 7
+
+      describe "stubbing FOO" do
+        it "can stub FOO with a different value" do
+          stub_const("FOO", 5)
+          FOO.should eq(5)
+        end
+
+        it "restores the stubbed constant when the example completes" do
+          FOO.should eq(7)
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub nested constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        describe SomeClass do
+          it "stubs the nested constant when it is fully qualified" do
+            stub_const("MyGem::SomeClass::FOO", 5)
+            SomeClass::FOO.should eq(5)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Transfer nested constants
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        describe SomeClass do
+          let(:fake_class) { Class.new }
+
+          it "does not transfer nested constants by default" do
+            stub_const("MyGem::SomeClass", fake_class)
+            expect { SomeClass::FOO }.to raise_error(NameError)
+          end
+
+          it "transfers nested constants when using :transfer_nested_constants => true" do
+            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => true)
+            SomeClass::FOO.should eq(7)
+          end
+
+          it "can specify a list of nested constants to transfer" do
+            stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => [:FOO])
+            SomeClass::FOO.should eq(7)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+

data/spec/vendor/rspec-mocks-2.14.4/features/mutating_constants/stub_undefined_constant.feature

@@ -0,0 +1,50 @@
+Feature: Stub Undefined Constant
+
+  Use `stub_const` to stub constants. When the constant is not already defined,
+  all the necessary intermediary modules will be dynamically created. When the
+  example completes, the intermediary module constants will be removed to return
+  the constant state to how it started.
+
+  Scenario: Stub top-level constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      describe "stubbing FOO" do
+        it "can stub undefined constant FOO" do
+          stub_const("FOO", 5)
+          FOO.should eq(5)
+        end
+
+        it "undefines the constant when the example completes" do
+          expect { FOO }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stub nested constant
+    Given a file named "stub_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+        end
+      end
+
+      module MyGem
+        describe SomeClass do
+          it "can stub an arbitrarily deep constant that is undefined" do
+            defined?(SomeClass::A).should be_false
+            stub_const("MyGem::SomeClass::A::B::C", 3)
+            SomeClass::A::B::C.should eq(3)
+            SomeClass::A.should be_a(Module)
+          end
+
+          it 'undefines the intermediary constants that were dynamically created' do
+            defined?(SomeClass).should be_true
+            defined?(SomeClass::A).should be_false
+          end
+        end
+      end
+      """
+    When I run `rspec stub_const_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/outside_rspec/configuration.feature

@@ -0,0 +1,62 @@
+Feature: configure any test framework to use rspec-mocks
+
+  Test frameworks that want to use rspec-mocks can use
+  RSpec::Mocks::setup(self) to hook into rspec-mocks. Doing so adds the
+  following:
+
+    To the object passed to setup:
+
+      double # creates a test double
+      mock   # creates a test double
+      stub   # creates a test double
+
+    To every object in the system:
+
+      should_receive
+      should_not_receive
+      stub
+
+  NOTICE: the stub() method that is added to the object passed to setup is not
+  the same stub() method that is added to every other object.
+
+  Scenario: RSpec::Mocks::setup(object) adds double, mock, and stub methods to the submitted object
+    Given a file named "foo.rb" with:
+      """ruby
+      require 'rspec/mocks'
+
+      class CodeExample
+        def init
+          RSpec::Mocks::setup(self)
+        end
+      end
+
+      example = CodeExample.new
+      example.init
+
+      puts example.respond_to?(:double)
+      puts example.respond_to?(:mock)
+      puts example.respond_to?(:stub)
+      """
+
+    When I run `ruby foo.rb`
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: RSpec::Mocks::setup(anything) adds methods to Object
+    Given a file named "foo.rb" with:
+      """ruby
+      require 'rspec/mocks'
+
+      RSpec::Mocks::setup(Object.new)
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run `ruby foo.rb`
+    Then the output should contain "true"
+    But  the output should not contain "false"
+

data/spec/vendor/rspec-mocks-2.14.4/features/outside_rspec/standalone.feature

@@ -0,0 +1,33 @@
+Feature: standalone
+
+  require "rspec/mocks/standalone" to expose the mock framework
+  outside the RSpec environment. This is especially useful for
+  exploring rspec-mocks in irb.
+
+  Scenario: method stub outside rspec
+    Given a file named "example.rb" with:
+      """ruby
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.stub(:say_hi) { "Hello!" }
+      puts greeter.say_hi
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "Hello!"
+
+  Scenario: message expectation outside rspec
+    Given a file named "example.rb" with:
+      """ruby
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.should_receive(:say_hi)
+
+      RSpec::Mocks.verify
+      """
+    When I run `ruby example.rb`
+    Then the output should contain "RSpec::Mocks::MockExpectationError"
+    And the output should contain "say_hi(any args)"
+    And the output should contain "expected: 1 time"
+    And the output should contain "received: 0 times"

data/spec/vendor/rspec-mocks-2.14.4/features/spies/spy_partial_mock_method.feature

@@ -0,0 +1,34 @@
+Feature: Spy on a stubbed method on a partial mock
+
+  You can also use `have_received` to verify that a stubbed method was invoked
+  on a partial mock.
+
+  Scenario: verify a stubbed method
+    Given a file named "verified_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = Object.new
+          invitation.stub(:deliver => true)
+          invitation.deliver
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec verified_spy_spec.rb`
+    Then the examples should all pass
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the expectation is not met" do
+          invitation = Object.new
+          invitation.stub(:deliver => true)
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "expected: 1 time"
+     And the output should contain "received: 0 times"

data/spec/vendor/rspec-mocks-2.14.4/features/spies/spy_pure_mock_method.feature

@@ -0,0 +1,76 @@
+Feature: Spy on a stubbed method on a pure mock
+
+  You can use `have_received` to verify that a stubbed method was invoked,
+  rather than setting an expectation for it to be invoked beforehand.
+
+  Scenario: verify a stubbed method
+    Given a file named "verified_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = double('invitation', :deliver => true)
+          invitation.deliver
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec verified_spy_spec.rb`
+    Then the examples should all pass
+
+  Scenario: verify a stubbed method with message expectations
+    Given a file named "verified_message_expectations_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = double('invitation', :deliver => true)
+          2.times { invitation.deliver(:expected, :arguments) }
+          invitation.should have_received(:deliver).
+            with(:expected, :arguments).
+            twice
+        end
+      end
+      """
+    When I run `rspec verified_message_expectations_spec.rb`
+    Then the examples should all pass
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the expectation is not met" do
+          invitation = double('invitation', :deliver => true)
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "expected: 1 time"
+     And the output should contain "received: 0 times"
+
+  Scenario: fail to verify message expectations
+    Given a file named "failed_message_expectations_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the arguments are different" do
+          invitation = double('invitation', :deliver => true)
+          invitation.deliver(:unexpected)
+          invitation.should have_received(:deliver).with(:expected, :arguments)
+        end
+      end
+      """
+    When I run `rspec failed_message_expectations_spec.rb`
+    Then the output should contain "expected: (:expected, :arguments)"
+    And the output should contain "got: (:unexpected)"
+
+  Scenario: generate a spy message
+    Given a file named "spy_message_spec.rb" with:
+      """ruby
+      describe "have_received" do
+      subject(:invitation) { double('invitation', :deliver => true) }
+        before { invitation.deliver }
+
+        it { should have_received(:deliver) }
+      end
+      """
+    When I run `rspec --format documentation spy_message_spec.rb`
+    Then the output should contain "should have received deliver"

data/spec/vendor/rspec-mocks-2.14.4/features/spies/spy_unstubbed_method.feature

@@ -0,0 +1,18 @@
+Feature: Spy on an unstubbed method
+
+  Using have_received on an unstubbed method will never pass, so rspec-mocks
+  issues a helpful error message.
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "raises a helpful error for unstubbed methods" do
+          object = Object.new
+          object.object_id
+          object.should have_received(:object_id)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "that method has not been stubbed"

data/spec/vendor/rspec-mocks-2.14.4/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,11 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  step %q{the output should contain "0 failures"}
+  step %q{the exit status should be 0}
+end
+
+# Useful for when the output is slightly different on different versions of ruby
+Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
+  unless [string1, string2].any? { |s| all_output =~ regexp(s) }
+    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{all_output}}
+  end
+end

data/spec/vendor/rspec-mocks-2.14.4/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  RUBY_PLATFORM =~ /java/ ? @aruba_timeout_seconds = 60 : @aruba_timeout_seconds = 5
+end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+

data/spec/vendor/rspec-mocks-2.14.4/features/support/rubinius.rb

@@ -0,0 +1,6 @@
+# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
+ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
+
+Around "@unsupported-on-rbx" do |scenario, block|
+  block.call unless defined?(Rubinius)
+end

data/spec/vendor/rspec-mocks-2.14.4/features/test_frameworks/test_unit.feature

@@ -0,0 +1,43 @@
+Feature: Test::Unit integration
+
+  rspec-mocks is a stand-alone gem that can be used without the rest of
+  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
+  prefer RSpec's approach to mocking/stubbing/doubles etc, you can have both.
+
+  The one downside is that failures are reported as errors with MiniTest.
+
+  Scenario: use rspec/mocks with Test::Unit
+    Given a file named "rspec_mocks_test.rb" with:
+      """ruby
+      require 'test/unit'
+      require 'rspec/mocks'
+
+      class RSpecMocksTest < Test::Unit::TestCase
+        def setup
+          RSpec::Mocks.setup(Object)
+          RSpec::Mocks.setup(self)
+        end
+
+        def test_passing_expectation
+          obj = Object.new
+          expect(obj).to receive(:message)
+          obj.message
+        end
+
+        def test_failing_expectation
+          obj = Object.new
+          expect(obj).to_not receive(:message)
+          obj.message
+        end
+
+        def test_with_deprecation_warning
+          obj = Object.new
+          obj.stub(:old_message) { RSpec.deprecate(:old_message, :replacement => :message) }
+          obj.old_message
+        end
+      end
+      """
+     When I run `ruby rspec_mocks_test.rb`
+     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
+     And the output should contain "expected: 0 times with any arguments"
+     And the output should contain "old_message is deprecated. Use message instead."

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

@@ -0,0 +1,94 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Chain
+        def initialize(recorder, *args, &block)
+          @recorder          = recorder
+          @expectation_args  = args
+          @expectation_block = block
+        end
+
+        module Customizations
+          # @macro [attach] record
+          #   @method $1(*args, &block)
+          #   Records the `$1` message for playback against an instance that
+          #   invokes a method stubbed or mocked using `any_instance`.
+          #
+          #   @see RSpec::Mocks::MessageExpectation#$1
+          #
+          def self.record(method_name)
+            class_eval(<<-EOM, __FILE__, __LINE__ + 1)
+              def #{method_name}(*args, &block)
+                record(:#{method_name}, *args, &block)
+              end
+            EOM
+          end
+
+          record :and_return
+          record :and_raise
+          record :and_throw
+          record :and_yield
+          record :and_call_original
+          record :with
+          record :once
+          record :twice
+          record :any_number_of_times
+          record :exactly
+          record :times
+          record :never
+          record :at_least
+          record :at_most
+        end
+
+        include Customizations
+
+        # @private
+        def playback!(instance)
+          message_expectation = create_message_expectation_on(instance)
+          messages.inject(message_expectation) do |object, message|
+            object.__send__(*message.first, &message.last)
+          end
+        end
+
+        # @private
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        # @private
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        def never
+          ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
+          super
+        end
+
+        private
+
+        def negated?
+          messages.any? { |(message, *_), _| message.to_sym == :never }
+        end
+
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @api private
+      class ExpectationChain < Chain
+        def expectation_fulfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+        end
+
+        def initialize(*args, &block)
+          @expectation_fulfilled = false
+          super
+        end
+
+        private
+        def verify_invocation_order(rspec_method_name, *args, &block)
+        end
+      end
+
+      # @api private
+      class PositiveExpectationChain < ExpectationChain
+
+        private
+
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil]
+          }
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,60 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class MessageChains < Hash
+        def initialize
+          super {|h,k| h[k] = []}
+        end
+
+        # @private
+        def add(method_name, chain)
+          self[method_name] << chain
+          chain
+        end
+
+        # @private
+        def remove_stub_chains_for!(method_name)
+          self[method_name].reject! {|chain| chain.is_a?(StubChain)}
+        end
+
+        # @private
+        def has_expectation?(method_name)
+          self[method_name].find {|chain| chain.is_a?(ExpectationChain)}
+        end
+
+        # @private
+        def all_expectations_fulfilled?
+          all? {|method_name, chains| chains.all? {|chain| chain.expectation_fulfilled?}}
+        end
+
+        # @private
+        def unfulfilled_expectations
+          map do |method_name, chains|
+            method_name.to_s if chains.last.is_a?(ExpectationChain) unless chains.last.expectation_fulfilled?
+          end.compact
+        end
+
+        # @private
+        def received_expected_message!(method_name)
+          self[method_name].each {|chain| chain.expectation_fulfilled!}
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          raise_if_second_instance_to_receive_message(instance)
+          self[method_name].each {|chain| chain.playback!(instance)}
+        end
+
+        private
+
+        def raise_if_second_instance_to_receive_message(instance)
+          @instance_with_expectation ||= instance if instance.is_a?(ExpectationChain)
+          if instance.is_a?(ExpectationChain) && !@instance_with_expectation.equal?(instance)
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end