dxruby_rp5 0.0.1

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/README.md

@@ -0,0 +1,73 @@
+### Stub return values
+
+    # create a double
+    obj = double()
+
+    # specify a return value using `:expect` syntax
+    allow(obj).to receive(:message) { :value }
+    allow(obj).to receive(:message).and_return(:value)
+
+    # specify a return value using `:should` syntax
+    obj.stub(:message) { :value }
+    obj.stub(:message => :value)
+    obj.stub(:message).and_return(:value)
+
+These forms are somewhat interchangeable. The difference is that the
+block contents are evaluated lazily when the `obj` receives the
+`message` message, whereas the others are evaluated as they are read.
+
+### Fake implementation
+
+    allow(obj).to receive(:message) do |arg1, arg2|
+      # set expectations about the args in this block
+      # and/or return  value
+    end
+
+    obj.stub(:message) do |arg1, arg2|
+      # set expectations about the args in this block
+      # and/or return a value
+    end
+
+### Raising/Throwing
+
+    allow(obj).to receive(:message).and_raise("this error")
+    allow(obj).to receive(:message).and_throw(:this_symbol)
+
+    obj.stub(:message).and_raise("this error")
+    obj.stub(:message).and_throw(:this_symbol)
+
+You can also use the block format:
+
+    allow(obj).to receive(:message) { raise "this error" }
+    allow(obj).to receive(:message) { throw :this_symbol }
+
+    obj.stub(:message) { raise "this error" }
+    obj.stub(:message) { throw :this_symbol }
+
+### Argument constraints
+
+#### Explicit arguments
+
+    allow(obj).to receive(:message).with('an argument') { ... }
+
+    obj.stub(:message).with('an argument') { ... }
+    obj.stub(:message).with('more_than', 'one_argument') { ... }
+
+#### Argument matchers
+
+    allow(obj).to receive(:message).with(anything()) { ... }
+    allow(obj).to receive(:message).with(an_instance_of(Money)) { ... }
+    allow(obj).to receive(:message).with(hash_including(:a => 'b')) { ... }
+    allow(obj).to receive(:message).with(array_including(1,2,3)) { ... }
+    # or
+    allow(obj).to receive(:message).with(array_including([1,2,3])) { ... }
+
+    obj.stub(:message).with(anything()) { ... }
+    obj.stub(:message).with(an_instance_of(Money)) { ... }
+    obj.stub(:message).with(hash_including(:a => 'b')) { ... }
+
+#### Regular expressions
+
+    allow(obj).to receive(:message).with(/abc/) { ... }
+
+    obj.stub(:message).with(/abc/) { ... }

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/any_instance.feature

@@ -0,0 +1,136 @@
+Feature: stub on any instance of a class
+
+  Use `any_instance.stub` on a class to tell any instance of that class to
+  return a value (or values) in response to a given message.  If no instance
+  receives the message, nothing happens.
+
+  Messages can be stubbed on any class, including those in Ruby's core library.
+
+  Note: You can use `allow_any_instance_of` when you don't have a reference
+  to the object that receives a message in your test. For more information,
+  see the message_expectations/allow_any_instance_of feature.
+
+  Scenario: any_instance stub with a single return value
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.stub" do
+        it "returns the specified value on any instance of the class" do
+          Object.any_instance.stub(:foo).and_return(:return_value)
+
+          o = Object.new
+          o.foo.should eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: any_instance stub with a hash
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.stub" do
+        context "with a hash" do
+          it "returns the hash values on any instance of the class" do
+            Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
+
+            o = Object.new
+            o.foo.should eq('foo')
+            o.bar.should eq('bar')
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: any_instance stub with specific arguments matchers
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.stub" do
+        context "with arguments" do
+          it "returns the stubbed value when arguments match" do
+            Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
+            Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
+
+            o = Object.new
+            o.foo(:param_one, :param_two).should eq(:result_one)
+            o.foo(:param_three, :param_four).should eq(:result_two)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.unstub" do
+        it "unstubs a stubbed method" do
+          class Object
+            def foo
+              :foo
+            end
+          end
+
+          Object.any_instance.stub(:foo)
+          Object.any_instance.unstub(:foo)
+
+          Object.new.foo.should eq(:foo)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.unstub" do
+        context "with both an expectation and a stub already set" do
+          it "only removes the stub" do
+            class Object
+              def foo
+                :foo
+              end
+            end
+            Object.any_instance.should_receive(:foo).and_return(:bar)
+            Object.any_instance.stub(:foo)
+            Object.any_instance.unstub(:foo)
+
+            Object.new.foo.should eq(:bar)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: stub a chain of methods an any instance
+    Given a file named "stub_chain_spec.rb" with:
+      """ruby
+      describe "stubbing a chain of methods" do
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a hash at the end" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three => :four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain("one.two.three").and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_chain_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/as_null_object.feature

@@ -0,0 +1,40 @@
+Feature: as_null_object
+
+  Use the `as_null_object` method to ignore any messages that aren't explicitly
+  set as stubs or message expectations.
+
+  EXCEPTION: `to_ary` will raise a NoMethodError unless explicitly stubbed in
+  order to support `flatten` on an Array containing a double.
+
+  Scenario: double acting as_null_object
+    Given a file named "as_null_object_spec.rb" with:
+      """ruby
+      describe "a double with as_null_object called" do
+        let(:null_object) { double('null object').as_null_object }
+
+        it "responds to any method that is not defined" do
+          null_object.should respond_to(:an_undefined_method)
+        end
+
+        it "allows explicit stubs using expect syntax" do
+          allow(null_object).to receive(:foo) { "bar" }
+          expect(null_object.foo).to eq("bar")
+        end
+
+        it "allows explicit stubs using should syntax" do
+          null_object.stub(:foo) { "bar" }
+          null_object.foo.should eq("bar")
+        end
+
+        it "allows explicit expectations" do
+          null_object.should_receive(:something)
+          null_object.something
+        end
+
+        it "supports Array#flatten" do
+          [null_object].flatten.should eq([null_object])
+        end
+      end
+      """
+    When I run `rspec as_null_object_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/simple_return_value_with_allow.feature

@@ -0,0 +1,44 @@
+Feature: allow with a simple return value
+
+  Use the `allow` method with the `receive` matcher on a test double or a real
+  object to tell the object to return a value (or values) in response to a given
+  message. Nothing happens if the message is never received.
+
+  Scenario: stub with no return value
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "a stub with no return value specified" do
+        let(:collaborator) { double("collaborator") }
+
+        it "returns nil" do
+          allow(collaborator).to receive(:message)
+          expect(collaborator.message).to be(nil)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: stubs with return values
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "a stub with a return value" do
+        context "specified in a block" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            allow(collaborator).to receive(:message) { :value }
+            expect(collaborator.message).to eq(:value)
+          end
+        end
+
+        context "specified with #and_return" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            allow(collaborator).to receive(:message).and_return(:value)
+            expect(collaborator.message).to eq(:value)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/simple_return_value_with_stub.feature

@@ -0,0 +1,64 @@
+Feature: stub with a simple return value
+
+  Use the `stub` method on a test double or a real object to tell the object to
+  return a value (or values) in response to a given message. Nothing happens if
+  the message is never received.
+
+  Scenario: stub with no return value
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "a stub with no return value specified" do
+        let(:collaborator) { double("collaborator") }
+
+        it "returns nil" do
+          collaborator.stub(:message)
+          collaborator.message.should be(nil)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: stubs with return values
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "a stub with a return value" do
+        context "specified in a block" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            collaborator.stub(:message) { :value }
+            collaborator.message.should eq(:value)
+          end
+        end
+
+        context "specified with #and_return" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            collaborator.stub(:message).and_return(:value)
+            collaborator.message.should eq(:value)
+          end
+        end
+
+        context "specified with a hash passed to #stub" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            collaborator.stub(:message_1 => :value_1, :message_2 => :value_2)
+            collaborator.message_1.should eq(:value_1)
+            collaborator.message_2.should eq(:value_2)
+          end
+        end
+
+        context "specified with a hash passed to #double" do
+          it "returns the specified value" do
+            collaborator = double("collaborator",
+              :message_1 => :value_1,
+              :message_2 => :value_2
+            )
+            collaborator.message_1.should eq(:value_1)
+            collaborator.message_2.should eq(:value_2)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/stub_chain.feature

@@ -0,0 +1,51 @@
+Feature: stub a chain of methods
+
+  Use the `stub_chain` method to stub a chain of two or more methods in one
+  statement.  Method chains are considered a design smell, but it's not really
+  the method chain itself that is the problem - it's the dependency chain
+  represented by a chain of messages to different objects:
+
+      foo.get_bar.get_baz
+
+  This is a Law of Demeter violation if `get_bar` returns an object other than
+  `foo`, and `get_baz` returns yet another object.
+
+  Fluent interfaces look similar from a caller's perspective, but don't
+  represent a dependency chain (the caller depends only on the object it is
+  calling). Consider this common example from Ruby on Rails:
+
+      Article.recent.by(current_user)
+
+  The `recent` and `by` methods return the same object, so this is not a Law of
+  Demeter violation.
+
+  Scenario: stub a chain of methods
+    Given a file named "stub_chain_spec.rb" with:
+      """ruby
+      describe "stubbing a chain of methods" do
+        subject { Object.new }
+
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            subject.stub_chain(:one, :two, :three).and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a hash at the end" do
+          it "returns the correct value" do
+            subject.stub_chain(:one, :two, :three => :four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            subject.stub_chain("one.two.three").and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_chain_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/stub_implementation.feature

@@ -0,0 +1,48 @@
+Feature: stub with substitute implementation
+
+  You can stub an implementation of a method (a.k.a. fake) by passing a block
+  to the `stub` method.
+
+  Scenario: stub implementation using `expect` syntax
+  Given a file named "stub_implementation_spec.rb" with:
+    """ruby
+    describe "a stubbed implementation" do
+      it "works" do
+        object = Object.new
+        allow(object).to receive(:foo) do |arg|
+          if arg == :this
+            "got this"
+          elsif arg == :that
+            "got that"
+          end
+        end
+
+        expect(object.foo(:this)).to eq("got this")
+        expect(object.foo(:that)).to eq("got that")
+      end
+    end
+    """
+  When I run `rspec stub_implementation_spec.rb`
+  Then the output should contain "1 example, 0 failures"
+
+  Scenario: stub implementation using `should` syntax
+    Given a file named "stub_implementation_spec.rb" with:
+      """ruby
+      describe "a stubbed implementation" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo) do |arg|
+            if arg == :this
+              "got this"
+            elsif arg == :that
+              "got that"
+            end
+          end
+
+          object.foo(:this).should eq("got this")
+          object.foo(:that).should eq("got that")
+        end
+      end
+      """
+    When I run `rspec stub_implementation_spec.rb`
+    Then the output should contain "1 example, 0 failures"

data/spec/vendor/rspec-mocks-2.14.4/features/method_stubs/to_ary.feature

@@ -0,0 +1,51 @@
+Feature: double handling to_ary
+
+  Ruby implicitly sends `to_ary` to all of the objects in an `Array` when the
+  array receives `flatten`:
+
+      [obj].flatten # => obj.to_ary
+
+  If `to_ary` raises a `NoMethodError`, Ruby sees that the object can not be coerced
+  into an array and moves on to the next object.
+
+  To support this, an RSpec double will raise a NoMethodError when it receives
+  `to_ary` _even if it is set `as_null_object`_, unless `to_ary` is explicitly
+  stubbed.
+
+  Scenario: double receiving to_ary
+    Given a file named "example.rb" with:
+      """ruby
+      describe "#to_ary" do
+        shared_examples "to_ary" do
+          it "can be overridden with a stub" do
+            obj.stub(:to_ary) { :non_nil_value }
+            obj.to_ary.should be(:non_nil_value)
+          end
+
+          it "supports Array#flatten" do
+            obj = double('foo')
+            [obj].flatten.should eq([obj])
+          end
+        end
+
+        context "sent to a double as_null_object" do
+          let(:obj) { double('obj').as_null_object }
+          include_examples "to_ary"
+
+          it "returns nil" do
+            expect( obj.to_ary ).to eq nil
+          end
+        end
+
+        context "sent to a double without as_null_object" do
+          let(:obj) { double('obj') }
+          include_examples "to_ary"
+
+          it "raises a NoMethodError" do
+            expect { obj.to_ary }.to raise_error(NoMethodError)
+          end
+        end
+      end
+     """
+    When I run `rspec example.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/mutating_constants/README.md

@@ -0,0 +1,82 @@
+## Mutating Constants
+
+### Stubbing
+
+Support is provided for stubbing constants. Like with method stubs, the
+stubbed constants will be restored to their original state when an
+example completes.
+
+``` ruby
+stub_const("Foo", fake_foo)
+Foo # => fake_foo
+```
+
+Stubbed constant names must be fully qualified; the current module
+nesting is not considered.
+
+``` ruby
+module MyGem
+  class SomeClass; end
+end
+
+module MyGem
+  describe "Something" do
+    let(:fake_class) { Class.new }
+
+    it "accidentally stubs the wrong constant" do
+      # this stubs ::SomeClass (in the top-level namespace),
+      # not MyGem::SomeClass like you probably mean.
+      stub_const("SomeClass", fake_class)
+    end
+
+    it "stubs the right constant" do
+      stub_const("MyGem::SomeClass", fake_class)
+    end
+  end
+end
+```
+
+When you stub a constant that is a module or a class, nested
+constants on the original module or class are not transferred
+by default, but you can use the `:transfer_nested_constants`
+option to tell rspec-mocks to transfer them:
+
+``` ruby
+class CardDeck
+  SUITS = [:Spades, :Diamonds, :Clubs, :Hearts]
+  NUM_CARDS = 52
+end
+
+fake_class = Class.new
+stub_const("CardDeck", fake_class)
+CardDeck # => fake_class
+CardDeck::SUITS # => raises uninitialized constant error
+CardDeck::NUM_CARDS # => raises uninitialized constant error
+
+stub_const("CardDeck", fake_class, :transfer_nested_constants => true)
+CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
+CardDeck::NUM_CARDS # => 52
+
+stub_const("CardDeck", fake_class, :transfer_nested_constants => [:SUITS])
+CardDeck::SUITS # => [:Spades, :Diamonds, :Clubs, :Hearts]
+CardDeck::NUM_CARDS # => raises uninitialized constant error
+```
+
+### Hiding
+
+Support is also provided for hiding constants. Hiding a constant temporarily
+removes it; it is restored to its original value after the test completes.
+
+```ruby
+FOO = 42
+hide_const("FOO")
+FOO => NameError: uninitialized constant FOO
+```
+
+Like stubbed constants, names must be fully qualified.
+
+Hiding constants that are already undefined has no effect.
+
+```ruby
+hide_const("NO_OP")
+```

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

@@ -0,0 +1,64 @@
+Feature: Hide Defined Constant
+
+  Use `hide_const` to remove a constant for the duration of a test.
+
+  Scenario: Hide top-level constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      FOO = 7
+
+      describe "hiding FOO" do
+        it "can hide FOO" do
+          hide_const("FOO")
+          expect { FOO }.to raise_error(NameError)
+        end
+
+        it "restores the hidden constant when the example completes" do
+          FOO.should eq(7)
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Hide nested constant
+    Given a file named "hide_const_spec.rb" with:
+      """ruby
+      module MyGem
+        class SomeClass
+          FOO = 7
+        end
+      end
+
+      module MyGem
+        describe SomeClass do
+          it "hides the nested constant when it is fully qualified" do
+            hide_const("MyGem::SomeClass::FOO")
+            expect { SomeClass::FOO }.to raise_error(NameError)
+          end
+
+          it "restores the hidden constant when the example completes" do
+            MyGem::SomeClass::FOO.should eq(7)
+          end
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Hiding undefined constant
+    Given a file named "hide_const_spec.rb" with:
+      """
+      describe "hiding UNDEFINED_CONSTANT" do
+        it "has no effect" do
+          hide_const("UNDEFINED_CONSTANT")
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+
+        it "is still undefined after the example completes" do
+          expect { UNDEFINED_CONSTANT }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec hide_const_spec.rb`
+    Then the examples should all pass