remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/README.md

@@ -0,0 +1,90 @@
+# Built-in Matchers
+
+Here is a list of matchers that ship with rspec-expectations. Each matcher
+can be used with `should` or `should_not` e.g.
+
+    result.should eq(3)
+    list.should_not be_empty
+
+## Object identity
+
+    actual.should be(expected) # passes if actual.equal?(expected)
+    
+## Object equivalence
+
+    actual.should eq(expected) # passes if actual == expected
+
+## Optional APIs for identity/equivalence
+
+    actual.should == expected     # passes if actual == expected
+    actual.should eql(expected)   # passes if actual.eql?(expected)
+    actual.should equal(expected) # passes if actual.equal?(expected)
+
+    # NOTE: this can't work in Ruby 1.8, so we don't support it at all:
+    #   actual.should != expected
+    # The reason is that Ruby 1.8 parses it as:
+    #   !(actual.should.==(expected)),
+    # so by the time RSpec sees it it has no way to know that it's
+    # been negated. Use either of these instead:
+    #   actual.should_not eq(expected)
+    #   actual.should_not == expected
+
+## Comparisons
+
+    actual.should be >  expected
+    actual.should be >= expected
+    actual.should be <= expected
+    actual.should be <  expected
+    actual.should =~ /expression/
+    actual.should match(/expression/)
+    actual.should be_within(delta).of(expected)
+
+## Types/classes
+
+    actual.should be_instance_of(expected)
+    actual.should be_kind_of(expected)
+
+## Truthiness and existentialism
+
+    actual.should be_true  # passes if actual is truthy (not nil or false)
+    actual.should be_false # passes if actual is falsy (nil or false)
+    actual.should be_nil   # passes if actual is nil
+    actual.should be       # passes if actual is truthy (not nil or false)
+
+## Expecting errors
+
+    expect { ... }.to raise_error
+    expect { ... }.to raise_error(ErrorClass)
+    expect { ... }.to raise_error("message")
+    expect { ... }.to raise_error(ErrorClass, "message")
+
+## Expecting throws
+
+    expect { ... }.to throw_symbol
+    expect { ... }.to throw_symbol(:symbol)
+    expect { ... }.to throw_symbol(:symbol, 'value')
+
+## Predicate matchers
+
+    actual.should be_xxx         # passes if actual.xxx?
+    actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+
+### Examples
+
+    [].should be_empty # passes because [].empty? returns true
+    { :a => 1 }.should have_key(:a) # passes because the hash has the key :a
+
+## Collection membership
+
+    actual.should include(expected)
+
+### Examples
+
+    [1,2,3].should include(1)
+    [1,2,3].should include(1, 2)
+    {:a => 'b'}.should include(:a => 'b')
+    "this string".should include("is str")
+
+## Ranges (1.9 only)
+
+    (1..10).should cover(3)

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/be.feature

@@ -0,0 +1,173 @@
+Feature: "be" matchers
+
+  There are several related "be" matchers:
+
+      obj.should be_true  # passes if obj is truthy (not nil or false)
+      obj.should be_false # passes if obj is falsy (nil or false)
+      obj.should be_nil   # passes if obj is nil
+      obj.should be       # passes if obj is truthy (not nil or false)
+
+  Scenario: be_true matcher
+    Given a file named "be_true_spec.rb" with:
+      """ruby
+      describe "be_true matcher" do
+        specify { true.should be_true }
+        specify { 7.should be_true }
+        specify { "foo".should be_true }
+        specify { nil.should_not be_true }
+        specify { false.should_not be_true }
+
+        # deliberate failures
+        specify { true.should_not be_true }
+        specify { 7.should_not be_true }
+        specify { "foo".should_not be_true }
+        specify { nil.should be_true }
+        specify { false.should be_true }
+      end
+      """
+    When I run `rspec be_true_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: "foo"
+      """
+    And the output should contain:
+      """
+             expected: true value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: true value
+                  got: false
+      """
+
+  Scenario: be_false matcher
+    Given a file named "be_false_spec.rb" with:
+      """ruby
+      describe "be_false matcher" do
+        specify { nil.should be_false }
+        specify { false.should be_false }
+        specify { true.should_not be_false }
+        specify { 7.should_not be_false }
+        specify { "foo".should_not be_false }
+
+        # deliberate failures
+        specify { nil.should_not be_false }
+        specify { false.should_not be_false }
+        specify { true.should be_false }
+        specify { 7.should be_false }
+        specify { "foo".should be_false }
+      end
+      """
+    When I run `rspec be_false_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: non-false value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: non-false value
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: "foo"
+      """
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """ruby
+      describe "be_nil matcher" do
+        specify { nil.should be_nil }
+        specify { false.should_not be_nil }
+        specify { true.should_not be_nil }
+        specify { 7.should_not be_nil }
+        specify { "foo".should_not be_nil }
+
+        # deliberate failures
+        specify { nil.should_not be_nil }
+        specify { false.should be_nil }
+        specify { true.should be_nil }
+        specify { 7.should be_nil }
+        specify { "foo".should be_nil }
+      end
+      """
+    When I run `rspec be_nil_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: not nil
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: "foo"
+      """
+
+  Scenario: be matcher
+    Given a file named "be_spec.rb" with:
+      """ruby
+      describe "be_matcher" do
+        specify { true.should be }
+        specify { 7.should be }
+        specify { "foo".should be }
+        specify { nil.should_not be }
+        specify { false.should_not be }
+
+        # deliberate failures
+        specify { true.should_not be }
+        specify { 7.should_not be }
+        specify { "foo".should_not be }
+        specify { nil.should be }
+        specify { false.should be }
+      end
+      """
+    When I run `rspec be_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures             |
+      | expected true to evaluate to false  |
+      | expected 7 to evaluate to false     |
+      | expected "foo" to evaluate to false |
+      | expected nil to evaluate to true    |
+      | expected false to evaluate to true  |

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/be_within.feature

@@ -0,0 +1,46 @@
+Feature: be_within matcher
+
+  Normal equality expectations do not work well for floating point values.
+  Consider this irb session:
+
+      > radius = 3
+        => 3 
+      > area_of_circle = radius * radius * Math::PI
+        => 28.2743338823081 
+      > area_of_circle == 28.2743338823081
+        => false 
+
+  Instead, you should use the be_within matcher to check that the value
+  is within a delta of your expected value:
+
+      area_of_circle.should be_within(0.1).of(28.3)
+
+  Note that the difference between the actual and expected values must be
+  smaller than your delta; if it is equal, the matcher will fail.
+
+  Scenario: basic usage
+    Given a file named "be_within_matcher_spec.rb" with:
+      """ruby
+      describe 27.5 do
+        it { should be_within(0.5).of(27.9) }
+        it { should be_within(0.5).of(28.0) }
+        it { should be_within(0.5).of(27.1) }
+        it { should be_within(0.5).of(27.0) }
+
+        it { should_not be_within(0.5).of(28.1) }
+        it { should_not be_within(0.5).of(26.9) }
+
+        # deliberate failures
+        it { should_not be_within(0.5).of(28) }
+        it { should_not be_within(0.5).of(27) }
+        it { should be_within(0.5).of(28.1) }
+        it { should be_within(0.5).of(26.9) }
+      end
+      """
+    When I run `rspec be_within_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 28   |
+      | expected 27.5 not to be within 0.5 of 27   |
+      | expected 27.5 to be within 0.5 of 28.1     |
+      | expected 27.5 to be within 0.5 of 26.9     |

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/cover.feature

@@ -0,0 +1,45 @@
+@ruby-1.9
+Feature: cover matcher
+
+  Use the cover matcher to specify that a range covers one or more
+  expected objects.  This works on any object that responds to #cover?  (such
+  as a Range):
+
+    (1..10).should cover(5)
+    (1..10).should cover(4, 6)
+    (1..10).should_not cover(11)
+
+  Scenario: range usage
+    Given a file named "range_cover_matcher_spec.rb" with:
+      """ruby
+      describe (1..10) do
+        it { should cover(4) }
+        it { should cover(6) }
+        it { should cover(8) }
+        it { should cover(4, 6) }
+        it { should cover(4, 6, 8) }
+        it { should_not cover(11) }
+        it { should_not cover(11, 12) }
+
+        # deliberate failures
+        it { should cover(11) }
+        it { should_not cover(4) }
+        it { should_not cover(6) }
+        it { should_not cover(8) }
+        it { should_not cover(4, 6, 8) }
+
+        # both of these should fail since it covers 5 but not 11
+        it { should cover(5, 11) }
+        it { should_not cover(5, 11) }
+      end
+      """
+    When I run `rspec range_cover_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 14 examples, 7 failures                 |
+      | expected 1..10 to cover 11              |
+      | expected 1..10 not to cover 4           |
+      | expected 1..10 not to cover 6           |
+      | expected 1..10 not to cover 8           |
+      | expected 1..10 not to cover 4, 6, and 8 |
+      | expected 1..10 to cover 5 and 11        |
+      | expected 1..10 not to cover 5 and 11    |

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/end_with.feature

@@ -0,0 +1,46 @@
+Feature: end_with matcher
+
+  Use the `end_with` matcher to specify that a string or array ends with the
+  expected characters or elements.
+
+    "this string".should end_with "string"
+    "this string".should_not end_with "stringy"
+    [0, 1, 2].should end_with 1, 2
+
+  Scenario: string usage
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "this string" do
+        it { should end_with "string" }
+        it { should_not end_with "stringy" }
+
+        # deliberate failures
+        it { should_not end_with "string" }
+        it { should end_with "stringy" }
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                          |
+      | expected "this string" not to end with "string" |
+      | expected "this string" to end with "stringy"    |
+
+  Scenario: array usage
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe [0, 1, 2, 3, 4] do
+        it { should end_with 4 }
+        it { should end_with 3, 4 }
+        it { should_not end_with 3 }
+        it { should_not end_with 0, 1, 2, 3, 4, 5 }
+
+        # deliberate failures
+        it { should_not end_with 4 }
+        it { should end_with 3 }
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 2 failures                     |
+      | expected [0, 1, 2, 3, 4] not to end with 4 |
+      | expected [0, 1, 2, 3, 4] to end with 3     |

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/equality.feature

@@ -0,0 +1,145 @@
+Feature: equality matchers
+
+  Ruby exposes several different methods for handling equality:
+
+      a.equal?(b) # object identity - a and b refer to the same object
+      a.eql?(b)   # object equivalence - a and b have the same value
+      a == b      # object equivalence - a and b have the same value with type conversions
+
+  Note that these descriptions are guidelines but are not forced by the
+  language. Any object can implement any of these methods with its own
+  semantics.
+
+  rspec-expectations ships with matchers that align with each of these methods:
+
+      a.should equal(b) # passes if a.equal?(b)
+      a.should eql(b)   # passes if a.eql?(b)
+      a.should == b     # passes if a == b
+
+  It also ships with two matchers that have more of a DSL feel to them:
+
+      a.should be(b) # passes if a.equal?(b)
+      a.should eq(b) # passes if a == b
+
+  These are a useful pair if you wish to avoid the warning that Ruby emits on
+  `a.should == b`
+
+  Scenario: compare using eq (==)
+    Given a file named "compare_using_eq.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to another string of the same value" do
+          "this string".should eq("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not eq("a different string")
+        end
+      end
+
+      describe "an integer" do
+        it "is equal to a float of the same value" do
+          5.should eq(5.0)
+        end
+      end
+      """
+    When I run `rspec compare_using_eq.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using ==
+    Given a file named "compare_using_==.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to another string of the same value" do
+          "this string".should == "this string"
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not == "a different string"
+        end
+      end
+
+      describe "an integer" do
+        it "is equal to a float of the same value" do
+          5.should == 5.0
+        end
+      end
+      """
+    When I run `rspec compare_using_==.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using eql (eql?)
+    Given a file named "compare_using_eql.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe "an integer" do
+        it "is equal to another integer of the same value" do
+          5.should eql(5)
+        end
+
+        it "is not equal to another integer of a different value" do
+          5.should_not eql(6)
+        end
+
+        it "is not equal to a float of the same value" do
+          5.should_not eql(5.0)
+        end
+
+      end
+      """
+    When I run `rspec compare_using_eql.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using equal (equal?)
+    Given a file named "compare_using_equal.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          string.should equal(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          "this string".should_not equal("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not equal("a different string")
+        end
+
+      end
+      """
+    When I run `rspec compare_using_equal.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using be (equal?)
+    Given a file named "compare_using_be.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          string.should be(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          "this string".should_not be("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not be("a different string")
+        end
+
+      end
+      """
+    When I run `rspec compare_using_be.rb`
+    Then the output should contain "3 examples, 0 failures"
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/exist.feature

@@ -0,0 +1,43 @@
+Feature: exist matcher
+
+  The exist matcher is used to specify that something exists
+  (as indicated by #exist? or #exists?):
+
+    obj.should exist # passes if obj.exist? or obj.exists?
+
+  Scenario: basic usage
+    Given a file named "exist_matcher_spec.rb" with:
+      """ruby
+      class Planet
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def inspect
+          "<Planet: #{name}>"
+        end
+
+        def exist? # also works with exists?
+          %w[Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune].include?(name)
+        end
+      end
+
+      describe "Earth" do
+        let(:earth) { Planet.new("Earth") }
+        specify { earth.should exist }
+        specify { earth.should_not exist } # deliberate failure
+      end
+
+      describe "Tatooine" do
+        let(:tatooine) { Planet.new("Tatooine") }
+        it { tatooine.should exist } # deliberate failure
+        it { tatooine.should_not exist }
+      end
+      """
+    When I run `rspec exist_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                |
+      | expected <Planet: Earth> not to exist |
+      | expected <Planet: Tatooine> to exist  |

data/vendor/bundle/gems/rspec-expectations-2.12.1/features/built_in_matchers/expect_change.feature

@@ -0,0 +1,59 @@
+Feature: expect change
+
+  Expect the execution of a block of code to change the state of an object.
+
+  Background:
+    Given a file named "lib/counter.rb" with:
+      """ruby
+      class Counter
+        class << self
+          def increment
+            @count ||= 0
+            @count += 1
+          end
+          
+          def count
+            @count ||= 0
+          end
+        end
+      end
+      """
+  
+  Scenario: expect change
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "counter"
+
+      describe Counter, "#increment" do
+        it "should increment the count" do
+          expect { Counter.increment }.to change{Counter.count}.from(0).to(1)
+        end
+
+        # deliberate failure
+        it "should increment the count by 2" do
+          expect { Counter.increment }.to change{Counter.count}.by(2)
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should contain "1 failure"
+    Then the output should contain "should have been changed by 2, but was changed by 1"
+
+  Scenario: expect no change
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "counter"
+
+      describe Counter, "#increment" do
+        it "should not increment the count by 1 (using to_not)" do
+          expect { Counter.increment }.to_not change{Counter.count}
+        end
+
+        it "should not increment the count by 1 (using not_to)" do
+          expect { Counter.increment }.not_to change{Counter.count}
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should contain "2 failures"
+    Then the output should contain "should not have changed, but did change from 1 to 2"