dxruby_rp5 0.0.1

data/spec/vendor/rspec-expectations-2.14.4/features/built_in_matchers/include.feature

@@ -0,0 +1,174 @@
+Feature: include matcher
+
+  Use the include matcher to specify that a collection includes one or more
+  expected objects.  This works on any object that responds to #include?  (such
+  as a string or array):
+
+    ```ruby
+    "a string".should include("a")
+    "a string".should include("str")
+    "a string".should include("str", "g")
+    "a string".should_not include("foo")
+
+    [1, 2].should include(1)
+    [1, 2].should include(1, 2)
+    [1, 2].should_not include(17)
+    ```
+
+  The matcher also provides flexible handling for hashes:
+
+    ```ruby
+    {:a => 1, :b => 2}.should include(:a)
+    {:a => 1, :b => 2}.should include(:a, :b)
+    {:a => 1, :b => 2}.should include(:a => 1)
+    {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
+    {:a => 1, :b => 2}.should_not include(:c)
+    {:a => 1, :b => 2}.should_not include(:a => 2)
+    {:a => 1, :b => 2}.should_not include(:c => 3)
+    ```
+
+  Scenario: array usage
+    Given a file named "array_include_matcher_spec.rb" with:
+      """ruby
+      describe [1, 3, 7] do
+        it { should include(1) }
+        it { should include(3) }
+        it { should include(7) }
+        it { should include(1, 7) }
+        it { should include(1, 3, 7) }
+        it { should_not include(17) }
+        it { should_not include(43, 100) }
+
+        # deliberate failures
+        it { should include(4) }
+        it { should_not include(1) }
+        it { should_not include(3) }
+        it { should_not include(7) }
+        it { should_not include(1, 3, 7) }
+
+        # both of these should fail since it includes 1 but not 9
+        it { should include(1, 9) }
+        it { should_not include(1, 9) }
+      end
+      """
+    When I run `rspec array_include_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 14 examples, 7 failures                       |
+      | expected [1, 3, 7] to include 4               |
+      | expected [1, 3, 7] not to include 1           |
+      | expected [1, 3, 7] not to include 3           |
+      | expected [1, 3, 7] not to include 7           |
+      | expected [1, 3, 7] not to include 1, 3, and 7 |
+      | expected [1, 3, 7] to include 1 and 9         |
+      | expected [1, 3, 7] not to include 1 and 9     |
+
+  Scenario: string usage
+    Given a file named "string_include_matcher_spec.rb" with:
+      """ruby
+      describe "a string" do
+        it { should include("str") }
+        it { should include("a", "str", "ng") }
+        it { should_not include("foo") }
+        it { should_not include("foo", "bar") }
+
+        # deliberate failures
+        it { should include("foo") }
+        it { should_not include("str") }
+        it { should include("str", "foo") }
+        it { should_not include("str", "foo") }
+      end
+      """
+    When I run `rspec string_include_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                             |
+      | expected "a string" to include "foo"               |
+      | expected "a string" not to include "str"           |
+      | expected "a string" to include "str" and "foo"     |
+      | expected "a string" not to include "str" and "foo" |
+
+  Scenario: hash usage
+    Given a file named "hash_include_matcher_spec.rb" with:
+      """ruby
+      describe Hash do
+        subject { { :a => 7, :b => 5 } }
+
+        it { should include(:a) }
+        it { should include(:b, :a) }
+        it { should include(:a => 7) }
+        it { should include(:b => 5, :a => 7) }
+        it { should_not include(:c) }
+        it { should_not include(:c, :d) }
+        it { should_not include(:d => 2) }
+        it { should_not include(:a => 5) }
+        it { should_not include(:b => 7, :a => 5) }
+
+        # deliberate failures
+        it { should_not include(:a) }
+        it { should_not include(:b, :a) }
+        it { should_not include(:a => 7) }
+        it { should_not include(:a => 7, :b => 5) }
+        it { should include(:c) }
+        it { should include(:c, :d) }
+        it { should include(:d => 2) }
+        it { should include(:a => 5) }
+        it { should include(:a => 5, :b => 7) }
+
+        # Mixed cases--the hash includes one but not the other.
+        # All 4 of these cases should fail.
+        it { should include(:a, :d) }
+        it { should_not include(:a, :d) }
+        it { should include(:a => 7, :d => 3) }
+        it { should_not include(:a => 7, :d => 3) }
+      end
+      """
+    When I run `rspec hash_include_matcher_spec.rb`
+    Then the output should contain "13 failure"
+
+  Scenario: fuzzy usage with matchers
+    Given a file named "fuzzy_include_matcher_spec.rb" with:
+      """
+      require 'ostruct'
+
+      class User < OpenStruct
+        def inspect
+          name
+        end
+      end
+
+      RSpec::Matchers.define :a_user_named do |expected|
+        match do |actual|
+          actual.is_a?(User) && (actual.name == expected)
+        end
+        description do
+          "a user named '#{expected}'"
+        end
+      end
+
+      describe "Collection of users" do
+        subject do
+          [User.new(:name => "Joe"),
+           User.new(:name => "Fred"),
+           User.new(:name => "John"),
+           User.new(:name => "Luke"),
+           User.new(:name => "David")]
+        end
+
+        it { should include( a_user_named "Joe" ) }
+        it { should include( a_user_named "Luke" ) }
+        it { should_not include( a_user_named "Richard" ) }
+        it { should_not include( a_user_named "Hayley" ) }
+
+        # deliberate failures
+        it { should include( a_user_named "Richard" ) }
+        it { should_not include( a_user_named "Fred" ) }
+        it { should include( a_user_named "Sarah" ) }
+        it { should_not include( a_user_named "Luke" ) }
+      end
+      """
+    When I run `rspec fuzzy_include_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                                     |
+      | expected [Joe, Fred, John, Luke, David] to include a user named 'Richard'  |
+      | expected [Joe, Fred, John, Luke, David] not to include a user named 'Fred' |
+      | expected [Joe, Fred, John, Luke, David] to include a user named 'Sarah'    |
+      | expected [Joe, Fred, John, Luke, David] not to include a user named 'Luke' |

data/spec/vendor/rspec-expectations-2.14.4/features/built_in_matchers/match.feature

@@ -0,0 +1,52 @@
+Feature: match matcher
+
+  The match matcher calls #match on the object, passing if #match returns a
+  truthy (not false or nil) value.  Regexp and String both provide a #match
+  method.
+
+    ```ruby
+    "a string".should match(/str/) # passes
+    "a string".should match(/foo/) # fails
+    /foo/.should match("food")     # passes
+    /foo/.should match("drinks")   # fails
+    ```
+
+  This is equivalent to using the =~ matcher (see the operator matchers
+  feature for more details).
+
+  Scenario: string usage
+    Given a file named "string_match_spec.rb" with:
+      """ruby
+      describe "a string" do
+        it { should match(/str/) }
+        it { should_not match(/foo/) }
+
+        # deliberate failures
+        it { should_not match(/str/) }
+        it { should match(/foo/) }
+      end
+      """
+    When I run `rspec string_match_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                 |
+      | expected "a string" not to match /str/ |
+      | expected "a string" to match /foo/     |
+
+  Scenario: regular expression usage
+    Given a file named "regexp_match_spec.rb" with:
+      """ruby
+      describe /foo/ do
+        it { should match("food") }
+        it { should_not match("drinks") }
+
+        # deliberate failures
+        it { should_not match("food") }
+        it { should match("drinks") }
+      end
+      """
+    When I run `rspec regexp_match_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures             |
+      | expected /foo/ not to match "food" |
+      | expected /foo/ to match "drinks"   |
+

data/spec/vendor/rspec-expectations-2.14.4/features/built_in_matchers/operators.feature

@@ -0,0 +1,227 @@
+Feature: operator matchers
+
+  RSpec provides a number of matchers that are based on Ruby's built-in
+  operators. These pretty much work like you expect. For example, each of these
+  pass:
+
+    ```ruby
+    7.should == 7
+    [1, 2, 3].should == [1, 2, 3]
+    "this is a string".should =~ /^this/
+    "this is a string".should_not =~ /^that/
+    String.should === "this is a string"
+    ```
+
+  You can also use comparison operators combined with the "be" matcher like
+  this:
+
+    ```ruby
+    37.should be < 100
+    37.should be <= 38
+    37.should be >= 2
+    37.should be > 7
+    ```
+
+  RSpec also provides a `=~` matcher for arrays that disregards differences in
+  the ording between the actual and expected array.  For example:
+
+    ```ruby
+    [1, 2, 3].should =~ [2, 3, 1] # pass
+    [:a, :c, :b].should =~ [:a, :c] # fail
+    ```
+
+  Scenario: numeric operator matchers
+    Given a file named "numeric_operator_matchers_spec.rb" with:
+      """ruby
+      describe 18 do
+        it { should == 18 }
+        it { should be < 20 }
+        it { should be > 15 }
+        it { should be <= 19 }
+        it { should be >= 17 }
+
+        it { should_not == 28 }
+
+        # deliberate failures
+        it { should == 28 }
+        it { should be < 15 }
+        it { should be > 20 }
+        it { should be <= 17 }
+        it { should be >= 19 }
+
+        it { should_not == 18 }
+      end
+      """
+     When I run `rspec numeric_operator_matchers_spec.rb`
+     Then the output should contain "12 examples, 6 failures"
+      And the output should contain:
+      """
+           Failure/Error: it { should == 28 }
+             expected: 28
+                  got: 18 (using ==)
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be < 15 }
+             expected: < 15
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be > 20 }
+             expected: > 20
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be <= 17 }
+             expected: <= 17
+                  got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be >= 19 }
+             expected: >= 19
+                  got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not == 18 }
+             expected not: == 18
+                      got:    18
+      """
+
+  Scenario: string operator matchers
+    Given a file named "string_operator_matchers_spec.rb" with:
+      """ruby
+      describe "Strawberry" do
+        it { should == "Strawberry" }
+        it { should be < "Tomato" }
+        it { should be > "Apple" }
+        it { should be <= "Turnip" }
+        it { should be >= "Banana" }
+        it { should =~ /berry/ }
+
+        it { should_not == "Peach" }
+        it { should_not =~ /apple/ }
+
+        it "reports that it is a string using ===" do
+          String.should === subject
+        end
+
+        # deliberate failures
+        it { should == "Peach" }
+        it { should be < "Cranberry" }
+        it { should be > "Zuchini" }
+        it { should be <= "Potato" }
+        it { should be >= "Tomato" }
+        it { should =~ /apple/ }
+
+        it { should_not == "Strawberry" }
+        it { should_not =~ /berry/ }
+
+        it "fails a spec asserting that it is a symbol" do
+          Symbol.should === subject
+        end
+      end
+      """
+     When I run `rspec string_operator_matchers_spec.rb`
+     Then the output should contain "18 examples, 9 failures"
+      And the output should contain:
+      """
+           Failure/Error: it { should == "Peach" }
+             expected: "Peach"
+                  got: "Strawberry" (using ==)
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be < "Cranberry" }
+             expected: < "Cranberry"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be > "Zuchini" }
+             expected: > "Zuchini"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be <= "Potato" }
+             expected: <= "Potato"
+                  got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should be >= "Tomato" }
+             expected: >= "Tomato"
+                  got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should =~ /apple/ }
+             expected: /apple/
+                  got: "Strawberry" (using =~)
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not == "Strawberry" }
+             expected not: == "Strawberry"
+                      got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not =~ /berry/ }
+             expected not: =~ /berry/
+                      got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: Symbol.should === subject
+             expected: "Strawberry"
+                  got: Symbol (using ===)
+      """
+
+  Scenario: array operator matchers
+    Given a file named "array_operator_matchers_spec.rb" with:
+      """ruby
+      describe [1, 2, 3] do
+        it { should == [1, 2, 3] }
+        it { should_not == [1, 3, 2] }
+
+        it { should =~ [1, 2, 3] }
+        it { should =~ [1, 3, 2] }
+        it { should =~ [2, 1, 3] }
+        it { should =~ [2, 3, 1] }
+        it { should =~ [3, 1, 2] }
+        it { should =~ [3, 2, 1] }
+
+        # deliberate failures
+        it { should_not == [1, 2, 3] }
+        it { should == [1, 3, 2] }
+        it { should =~ [1, 2, 1] }
+      end
+      """
+     When I run `rspec array_operator_matchers_spec.rb`
+     Then the output should contain "11 examples, 3 failures"
+      And the output should contain:
+      """
+           Failure/Error: it { should_not == [1, 2, 3] }
+             expected not: == [1, 2, 3]
+                      got:    [1, 2, 3]
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should == [1, 3, 2] }
+             expected: [1, 3, 2]
+                  got: [1, 2, 3] (using ==)
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should =~ [1, 2, 1] }
+             expected collection contained:  [1, 1, 2]
+             actual collection contained:    [1, 2, 3]
+             the missing elements were:      [1]
+             the extra elements were:        [3]
+      """
+

data/spec/vendor/rspec-expectations-2.14.4/features/built_in_matchers/predicates.feature

@@ -0,0 +1,137 @@
+Feature: predicate matchers
+
+  Ruby objects commonly provide predicate methods:
+
+    ```ruby
+    7.zero?                  # => false
+    0.zero?                  # => true
+    [1].empty?               # => false
+    [].empty?                # => true
+    { :a => 5 }.has_key?(:b) # => false
+    { :b => 5 }.has_key?(:b) # => true
+    ```
+
+  You could use a basic equality matcher to set expectations on these:
+
+    ```ruby
+    7.zero?.should == true # fails with "expected true, got false (using ==)"
+    ```
+
+  ...but RSpec provides dynamic predicate matchers that are more readable and
+  provide better failure output.
+
+  For any predicate method, RSpec gives you a corresponding matcher.  Simply
+  prefix the method with `be_` and remove the question mark.  Examples:
+
+    ```ruby
+    7.should_not be_zero       # calls 7.zero?
+    [].should be_empty         # calls [].empty?
+    x.should be_multiple_of(3) # calls x.multiple_of?(3)
+    ```
+
+  Alternately, for a predicate method that begins with `has_` like
+  `Hash#has_key?`, RSpec allows you to use an alternate form since `be_has_key`
+  makes no sense.
+
+    ```ruby
+    hash.should have_key(:foo)       # calls hash.has_key?(:foo)
+    array.should_not have_odd_values # calls array.has_odd_values?
+    ```
+
+  In either case, RSpec provides nice, clear error messages, such as:
+
+    `expected zero? to return true, got false`
+
+  Any arguments passed to the matcher will be passed on to the predicate method.
+
+  Scenario: should be_zero (based on Fixnum#zero?)
+    Given a file named "should_be_zero_spec.rb" with:
+      """ruby
+      describe 0 do
+        it { should be_zero }
+      end
+
+      describe 7 do
+        it { should be_zero } # deliberate failure
+      end
+      """
+    When I run `rspec should_be_zero_spec.rb`
+    Then the output should contain "2 examples, 1 failure"
+     And the output should contain "expected zero? to return true, got false"
+
+  Scenario: should_not be_empty (based on Array#empty?)
+    Given a file named "should_not_be_empty_spec.rb" with:
+      """ruby
+      describe [1, 2, 3] do
+        it { should_not be_empty }
+      end
+
+      describe [] do
+        it { should_not be_empty } # deliberate failure
+      end
+      """
+    When I run `rspec should_not_be_empty_spec.rb`
+    Then the output should contain "2 examples, 1 failure"
+     And the output should contain "expected empty? to return false, got true"
+
+   Scenario: should have_key (based on Hash#has_key?)
+    Given a file named "should_have_key_spec.rb" with:
+      """ruby
+      describe Hash do
+        subject { { :foo => 7 } }
+        it { should have_key(:foo) }
+        it { should have_key(:bar) } # deliberate failure
+      end
+      """
+    When I run `rspec should_have_key_spec.rb`
+    Then the output should contain "2 examples, 1 failure"
+     And the output should contain "expected #has_key?(:bar) to return true, got false"
+
+   Scenario: should_not have_all_string_keys (based on custom #has_all_string_keys? method)
+     Given a file named "should_not_have_all_string_keys_spec.rb" with:
+       """ruby
+       class Hash
+         def has_all_string_keys?
+           keys.all? { |k| String === k }
+         end
+       end
+
+       describe Hash do
+         context 'with symbol keys' do
+           subject { { :foo => 7, :bar => 5 } }
+           it { should_not have_all_string_keys }
+         end
+
+         context 'with string keys' do
+           subject { { 'foo' => 7, 'bar' => 5 } }
+           it { should_not have_all_string_keys } # deliberate failure
+         end
+       end
+       """
+     When I run `rspec should_not_have_all_string_keys_spec.rb`
+     Then the output should contain "2 examples, 1 failure"
+      And the output should contain "expected #has_all_string_keys? to return false, got true"
+
+   Scenario: matcher arguments are passed on to the predicate method
+     Given a file named "predicate_matcher_argument_spec.rb" with:
+       """ruby
+       class Fixnum
+         def multiple_of?(x)
+           (self % x).zero?
+         end
+       end
+
+       describe 12 do
+         it { should be_multiple_of(3) }
+         it { should_not be_multiple_of(7) }
+
+         # deliberate failures
+         it { should_not be_multiple_of(4) }
+         it { should be_multiple_of(5) }
+       end
+       """
+     When I run `rspec predicate_matcher_argument_spec.rb`
+     Then the output should contain "4 examples, 2 failures"
+      And the output should contain "expected multiple_of?(4) to return false, got true"
+      And the output should contain "expected multiple_of?(5) to return true, got false"
+

data/spec/vendor/rspec-expectations-2.14.4/features/built_in_matchers/respond_to.feature

@@ -0,0 +1,84 @@
+Feature: respond_to matcher
+
+  Use the respond_to matcher to specify details of an object's interface.  In
+  its most basic form:
+
+    ```ruby
+    obj.should respond_to(:foo) # pass if obj.respond_to?(:foo)
+    ```
+
+  You can specify that an object responds to multiple messages in a single
+  statement with multiple arguments passed to the matcher:
+
+    ```ruby
+    obj.should respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
+    ```
+
+  If the number of arguments accepted by the method is important to you,
+  you can specify that as well:
+
+    ```ruby
+    obj.should respond_to(:foo).with(1).argument
+    obj.should respond_to(:bar).with(2).arguments
+    ```
+
+  Note that this matcher relies entirely upon #respond_to?.  If an object
+  dynamically responds to a message via #method_missing, but does not indicate
+  this via #respond_to?, then this matcher will give you false results.
+
+  Scenario: basic usage
+    Given a file named "respond_to_matcher_spec.rb" with:
+      """ruby
+      describe "a string" do
+        it { should respond_to(:length) }
+        it { should respond_to(:hash, :class, :to_s) }
+        it { should_not respond_to(:to_model) }
+        it { should_not respond_to(:compact, :flatten) }
+
+        # deliberate failures
+        it { should respond_to(:to_model) }
+        it { should respond_to(:compact, :flatten) }
+        it { should_not respond_to(:length) }
+        it { should_not respond_to(:hash, :class, :to_s) }
+
+        # mixed examples--String responds to :length but not :flatten
+        # both specs should fail
+        it { should respond_to(:length, :flatten) }
+        it { should_not respond_to(:length, :flatten) }
+      end
+      """
+    When I run `rspec respond_to_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 6 failures                                    |
+      | expected "a string" to respond to :to_model                |
+      | expected "a string" to respond to :compact, :flatten       |
+      | expected "a string" not to respond to :length              |
+      | expected "a string" not to respond to :hash, :class, :to_s |
+      | expected "a string" to respond to :flatten                 |
+      | expected "a string" not to respond to :length              |
+
+  Scenario: specify arguments
+    Given a file named "respond_to_matcher_argument_checking_spec.rb" with:
+      """ruby
+      describe 7 do
+        it { should respond_to(:zero?).with(0).arguments }
+        it { should_not respond_to(:zero?).with(1).argument }
+
+        it { should respond_to(:between?).with(2).arguments }
+        it { should_not respond_to(:between?).with(7).arguments }
+
+        # deliberate failures
+        it { should respond_to(:zero?).with(1).argument }
+        it { should_not respond_to(:zero?).with(0).arguments }
+
+        it { should respond_to(:between?).with(7).arguments }
+        it { should_not respond_to(:between?).with(2).arguments }
+      end
+      """
+    When I run `rspec respond_to_matcher_argument_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                  |
+      | expected 7 to respond to :zero? with 1 argument         |
+      | expected 7 not to respond to :zero? with 0 arguments    |
+      | expected 7 to respond to :between? with 7 arguments     |
+      | expected 7 not to respond to :between? with 2 arguments |