rspec-expectations 2.0.0.beta.22 → 2.0.0.rc

data/.gitignore

@@ -1,6 +1,6 @@
 *.sw?
 .DS_Store
-coverage
+coverage*
 rdoc
 pkg
 doc

data/Gemfile

@@ -9,6 +9,7 @@ gem "rspec-expectations", :path => "."
 gem "rspec-core", :path => "../rspec-core"
 gem "rspec-mocks", :path => "../rspec-mocks"
 gem "watchr"
+gem "rcov"
 
 case RUBY_VERSION
 when '1.9.2'

data/{History.md → History.markdown}

@@ -1,5 +1,16 @@
 ## rspec-expectations release history (incomplete)
 
+### 2.0.0.rc / 2010-10-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.22...v2.0.0.rc)
+
+* Enhancements
+  * require 'rspec/expectations' in a T::U or MiniUnit suite (Josep M. Bach)
+
+* Bug fixes
+  * change by 0 passes/fails correctly (Len Smith)
+  * Add description to satisfy matcher
+
 ### 2.0.0.beta.22 / 2010-09-12
 
 [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.20...v2.0.0.beta.22)
@@ -13,4 +24,3 @@
 
 * Bug fixes
   * should[_not] change now handles boolean values correctly
-

data/Rakefile

@@ -5,6 +5,7 @@ Bundler::GemHelper.install_tasks
 require 'rake'
 require 'rake/rdoctask'
 require 'rspec/core/rake_task'
+require 'rspec/expectations/version'
 require 'cucumber/rake/task'
 
 RSpec::Core::RakeTask.new(:spec)
@@ -17,8 +18,22 @@ class Cucumber::Rake::Task::ForkedCucumberRunner
   end
 end
 
-Cucumber::Rake::Task.new do |t|
+desc "Run all examples using rcov"
+RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
+  t.rcov = true
+  t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+  t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
+end
+
+task :cleanup_rcov_files do
+  rm_rf 'coverage.data'
+end
+
+Cucumber::Rake::Task.new :cucumber => :cleanup_rcov_files do |t|
   t.cucumber_opts = %w{--format progress}
+  t.rcov = true
+  t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+  t.rcov_opts << %[--text-report --sort coverage --aggregate coverage.data]
 end
 
 task :default => [:spec, :cucumber]

data/features/expectations/implicit_docstrings.feature

@@ -24,7 +24,7 @@ Feature: implicit docstrings
     And the output should contain "should include 2"
     And the output should contain "should respond to #size"
 
-  Scenario Outline: run failing examples
+  Scenario: run failing examples
     Given a file named "failing_implicit_docstrings_spec.rb" with:
     """
     describe "Failing examples with no descriptions" do
@@ -48,5 +48,5 @@ Feature: implicit docstrings
 
     Then the output should contain "should equal 2"
     And the output should contain "should be > 5"
-    And the output should contain "should include "b""
+    And the output should contain "should include 4"
     And the output should contain "should not respond to #size"

data/features/matchers/expect_error.feature

@@ -1,6 +1,6 @@
 Feature: expect error
 
-  Expect a proc to change the state of some object.
+  Expect a proc to raise an error when called.
   
   Scenario: expect error
     Given a file named "expect_error_spec.rb" with:

data/features/matchers/have.feature

@@ -0,0 +1,103 @@
+Feature: have matchers
+
+  RSpec provides several matchers that make it easy to set expectations about the
+  size of a collection.  There are three basic forms:
+
+    * collection.should have(x).items
+    * collection.should have_at_least(x).items
+    * collection.should have_at_most(x).items
+
+  In addition, #have_exactly is provided as an alias to #have.
+
+  These work on any collection-like object--the object just needs to respond to #size
+  or #length (or both).  When the matcher is called directly on a collection object,
+  the #items call is pure syntactic sugar.  You can use anything you want here.  These
+  are equivalent:
+
+    * collection.should have(x).items
+    * collection.should have(x).things
+
+  You can also use this matcher on a non-collection object that returns a collection
+  from one of its methods.  For example, Dir#entries returns an array, so you could
+  set an expectation using the following:
+
+    Dir.new("my/directory").should have(7).entries
+
+  Scenario: have(x).items on a collection
+    Given a file named "have_items_spec.rb" with:
+      """
+      describe [1, 2, 3] do
+        it { should have(3).items }
+        it { should_not have(2).items }
+        it { should_not have(4).items }
+
+        it { should have_exactly(3).items }
+        it { should_not have_exactly(2).items }
+        it { should_not have_exactly(4).items }
+
+        it { should have_at_least(2).items }
+        it { should have_at_most(4).items }
+
+        # deliberate failures
+        it { should_not have(3).items }
+        it { should have(2).items }
+        it { should have(4).items }
+
+        it { should_not have_exactly(3).items }
+        it { should have_exactly(2).items }
+        it { should have_exactly(4).items }
+
+        it { should have_at_least(4).items }
+        it { should have_at_most(2).items }
+      end
+      """
+     When I run "rspec have_items_spec.rb"
+     Then the output should contain "16 examples, 8 failures"
+      And the output should contain "expected target not to have 3 items, got 3"
+      And the output should contain "expected 2 items, got 3"
+      And the output should contain "expected 4 items, got 3"
+      And the output should contain "expected at least 4 items, got 3"
+      And the output should contain "expected at most 2 items, got 3"
+
+  Scenario: have(x).words on a String when String#words is defined
+    Given a file named "have_words_spec.rb" with:
+      """
+      class String
+        def words
+          split(' ')
+        end
+      end
+
+      describe "a sentence with some words" do
+        it { should have(5).words }
+        it { should_not have(4).words }
+        it { should_not have(6).words }
+
+        it { should have_exactly(5).words }
+        it { should_not have_exactly(4).words }
+        it { should_not have_exactly(6).words }
+
+        it { should have_at_least(4).words }
+        it { should have_at_most(6).words }
+
+        # deliberate failures
+        it { should_not have(5).words }
+        it { should have(4).words }
+        it { should have(6).words }
+
+        it { should_not have_exactly(5).words }
+        it { should have_exactly(4).words }
+        it { should have_exactly(6).words }
+
+        it { should have_at_least(6).words }
+        it { should have_at_most(4).words }
+      end
+      """
+     When I run "rspec have_words_spec.rb"
+     Then the output should contain "16 examples, 8 failures"
+      And the output should contain "expected target not to have 5 words, got 5"
+      And the output should contain "expected 4 words, got 5"
+      And the output should contain "expected 6 words, got 5"
+      And the output should contain "expected at least 6 words, got 5"
+      And the output should contain "expected at most 4 words, got 5"
+

data/features/matchers/operators.feature

@@ -0,0 +1,280 @@
+Feature: Operator Matchers
+
+  RSpec provides a number of matchers that are based on Ruby's built-in
+  operators.  These mostly work like you expect.  For example, each of these pass:
+
+    * 7.should == 7
+    * 25.2.should < 100
+    * 8.should > 7
+    * 17.should <= 17
+    * 3.should >= 2
+    * [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"
+
+  RSpec also provides a `=~` matcher for arrays that disregards differences in
+  the ording between the actual and expected array.  For example:
+
+    * [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:
+      """
+      describe 18 do
+        it { should == 18 }
+        it { should < 20 }
+        it { should > 15 }
+        it { should <= 19 }
+        it { should >= 17 }
+
+        it { should_not == 28 }
+        it { should_not < 15 }
+        it { should_not > 20 }
+        it { should_not <= 17 }
+        it { should_not >= 19 }
+
+        # deliberate failures
+        it { should == 28 }
+        it { should < 15 }
+        it { should > 20 }
+        it { should <= 17 }
+        it { should >= 19 }
+
+        it { should_not == 18 }
+        it { should_not < 20 }
+        it { should_not > 15 }
+        it { should_not <= 19 }
+        it { should_not >= 17 }
+      end
+      """
+     When I run "rspec numeric_operator_matchers_spec.rb"
+     Then the output should contain "20 examples, 10 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 < 15 }
+           expected: < 15,
+                got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should > 20 }
+           expected: > 20,
+                got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should <= 17 }
+           expected: <= 17,
+                got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should >= 19 }
+           expected: >= 19,
+                got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not == 18 }
+           expected not: == 18,
+                    got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not < 20 }
+           expected not: < 20,
+                    got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not > 15 }
+           expected not: > 15,
+                    got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not <= 19 }
+           expected not: <= 19,
+                    got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not >= 17 }
+           expected not: >= 17,
+                    got:    18
+      """
+
+  Scenario: string operator matchers
+    Given a file named "string_operator_matchers_spec.rb" with:
+      """
+      describe "Strawberry" do
+        it { should == "Strawberry" }
+        it { should < "Tomato" }
+        it { should > "Apple" }
+        it { should <= "Turnip" }
+        it { should >= "Banana" }
+        it { should =~ /berry/ }
+
+        it { should_not == "Peach" }
+        it { should_not < "Cranberry" }
+        it { should_not > "Zuchini" }
+        it { should_not <= "Potato" }
+        it { should_not >= "Tomato" }
+        it { should_not =~ /apple/ }
+
+        it "reports that it is a string using ===" do
+          String.should === subject
+        end
+
+        # deliberate failures
+        it { should == "Peach" }
+        it { should < "Cranberry" }
+        it { should > "Zuchini" }
+        it { should <= "Potato" }
+        it { should >= "Tomato" }
+        it { should =~ /apple/ }
+
+        it { should_not == "Strawberry" }
+        it { should_not < "Tomato" }
+        it { should_not > "Apple" }
+        it { should_not <= "Turnip" }
+        it { should_not >= "Banana" }
+        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 "26 examples, 13 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 < "Cranberry" }
+           expected: < "Cranberry",
+                got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should > "Zuchini" }
+           expected: > "Zuchini",
+                got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should <= "Potato" }
+           expected: <= "Potato",
+                got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should >= "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 < "Tomato" }
+           expected not: < "Tomato",
+                    got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not > "Apple" }
+           expected not: > "Apple",
+                    got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not <= "Turnip" }
+           expected not: <= "Turnip",
+                    got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { should_not >= "Banana" }
+           expected not: >= "Banana",
+                    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:
+      """
+      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/features/matchers/predicates.feature

@@ -0,0 +1,128 @@
+Feature: predicate matchers
+
+  Ruby objects commonly provide predicate methods:
+
+    * 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:
+
+    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:
+
+    * 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.
+
+    * 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:
+      """
+      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:
+      """
+      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:
+      """
+      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:
+       """
+       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?(nil) 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:
+       """
+       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/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,7 @@
+# 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| combined_output =~ Regexp.compile(s) }
+    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{combined_output}}
+  end
+end
+

data/features/test_frameworks/test_unit.feature

@@ -0,0 +1,29 @@
+Feature: Test::Unit integration
+
+  RSpec-expectations is a stand-alone gem that can be used without
+  the rest of RSpec.  It can easily be used with another test
+  framework such as Test::Unit if you like RSpec's should/should_not
+  syntax but prefer the test organization of another framework.
+
+  Scenario: Basic Test::Unit usage
+    Given a file named "rspec_expectations_test.rb" with:
+      """
+      require 'test/unit'
+      require 'rspec/expectations'
+
+      class RSpecExpectationsTest < Test::Unit::TestCase
+        def test_passing_expectation
+          x = 1 + 3
+          x.should == 4
+        end
+
+        def test_failing_expectation
+          array = [1, 2]
+          array.should be_empty
+        end
+      end
+      """
+     When I run "ruby rspec_expectations_test.rb"
+     Then the output should contain "2 tests"
+      And the output should contain "1 failure" or "1 error"
+      And the output should contain "expected empty? to return true, got false"

data/lib/rspec/expectations/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Expectations # :nodoc:
     module Version # :nodoc:
-      STRING = '2.0.0.beta.22'
+      STRING = '2.0.0.rc'
     end
   end
 end

data/lib/rspec/matchers.rb

@@ -158,6 +158,14 @@ module RSpec
     if RSpec.respond_to?(:configure)
       RSpec.configure {|c| c.include self}
     end
+
+    # Include Matchers for other test frameworks
+    if defined?(Test::Unit::TestCase)
+      Test::Unit::TestCase.send(:include, self)
+    end
+    if defined?(MiniTest::Unit::TestCase)
+      MiniTest::Unit::TestCase.send(:include, self)
+    end
   end
 end
 

data/lib/rspec/matchers/change.rb

@@ -16,8 +16,8 @@ module RSpec
         @before = evaluate_value_proc
         event_proc.call
         @after = evaluate_value_proc
-        
-        changed? && matches_before? && matches_after? && matches_amount? && matches_min? && matches_max?
+      
+        (!change_expected? || changed?) && matches_before? && matches_after? && matches_amount? && matches_min? && matches_max?
       end
 
       def raise_block_syntax_error
@@ -92,6 +92,10 @@ MESSAGE
         @message || "result"
       end
 
+      def change_expected?
+        @amount != 0
+      end
+
       def changed?
         @before != @after
       end

data/lib/rspec/matchers/satisfy.rb

@@ -19,6 +19,10 @@ module RSpec
       def failure_message_for_should_not
         "expected #{@actual} not to satisfy block"
       end
+
+      def description
+        "satisfy block"
+      end
     end
     
     # :call-seq:

data/spec/rspec/matchers/change_spec.rb

@@ -123,6 +123,10 @@ describe "should change(actual, message).by(expected)" do
     expect { @instance.some_value += 1 }.to change(@instance, :some_value).by(1)
   end
 
+  it "passes when attribute is not changed and expected amount is 0" do
+    expect { @instance.some_value += 0 }.to change(@instance, :some_value).by(0)
+  end
+
   it "fails when the attribute is changed by unexpected amount" do
     expect do
       expect { @instance.some_value += 2 }.to change(@instance, :some_value).by(1)

data/spec/rspec/matchers/matchers_spec.rb

@@ -1,2 +1,51 @@
 require 'spec_helper'
 
+module Test
+  module Unit
+    class TestCase
+    end
+  end
+end
+
+module MiniTest
+  module Unit
+    class TestCase
+    end
+  end
+end
+
+module RSpec
+  describe Matchers do
+
+    let(:sample_matchers) do
+      [:be,
+       :be_close,
+       :be_instance_of,
+       :be_kind_of]
+    end
+
+    context "once required" do
+
+      before(:all) do
+        path = File.expand_path("../../../../#{path}", __FILE__)
+        load File.join(path, 'lib/rspec/matchers.rb')
+      end
+
+      it "includes itself in Test::Unit::TestCase" do
+        test_unit_case = Test::Unit::TestCase.new
+        sample_matchers.each do |sample_matcher|
+            test_unit_case.should respond_to(sample_matcher)
+        end
+      end
+
+      it "includes itself in MiniTest::Unit::TestCase" do
+        minitest_case = MiniTest::Unit::TestCase.new
+        sample_matchers.each do |sample_matcher|
+            minitest_case.should respond_to(sample_matcher)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/rspec/matchers/satisfy_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe "should satisfy { block }" do
+  it "describes itself" do
+    satisfy.description.should eq("satisfy block")
+  end
+
   it "passes if block returns true" do
     true.should satisfy { |val| val }
     true.should satisfy do |val|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-expectations
 version: !ruby/object:Gem::Version 
+  hash: 7712058
   prerelease: true
   segments: 
   - 2
   - 0
   - 0
-  - beta
-  - 22
-  version: 2.0.0.beta.22
+  - rc
+  version: 2.0.0.rc
 platform: ruby
 authors: 
 - David Chelimsky
@@ -17,88 +17,91 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-12 00:00:00 -05:00
+date: 2010-10-04 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: diff-lcs
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 1
         - 2
         version: 1.1.2
+  requirement: *id001
   type: :runtime
+  name: diff-lcs
   prerelease: false
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: cucumber
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         - 6
         - 2
         version: 0.6.2
+  requirement: *id002
   type: :development
+  name: cucumber
   prerelease: false
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: aruba
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 25
         segments: 
         - 0
         - 1
         - 1
         version: 0.1.1
+  requirement: *id003
   type: :development
+  name: aruba
   prerelease: false
-  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rspec-core
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7712058
         segments: 
         - 2
         - 0
         - 0
-        - beta
-        - 22
-        version: 2.0.0.beta.22
+        - rc
+        version: 2.0.0.rc
+  requirement: *id004
   type: :development
+  name: rspec-core
   prerelease: false
-  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: rspec-mocks
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7712058
         segments: 
         - 2
         - 0
         - 0
-        - beta
-        - 22
-        version: 2.0.0.beta.22
+        - rc
+        version: 2.0.0.rc
+  requirement: *id005
   type: :development
+  name: rspec-mocks
   prerelease: false
-  version_requirements: *id005
 description: rspec expectations (should[_not] and matchers)
 email: dchelimsky@gmail.com;chad.humphries@gmail.com
 executables: []
@@ -111,7 +114,7 @@ files:
 - .document
 - .gitignore
 - Gemfile
-- History.md
+- History.markdown
 - License.txt
 - README.markdown
 - Rakefile
@@ -130,7 +133,12 @@ files:
 - features/matchers/equality.feature
 - features/matchers/expect_change.feature
 - features/matchers/expect_error.feature
+- features/matchers/have.feature
+- features/matchers/operators.feature
+- features/matchers/predicates.feature
+- features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
+- features/test_frameworks/test_unit.feature
 - lib/rspec-expectations.rb
 - lib/rspec/expectations.rb
 - lib/rspec/expectations/backward_compatibility.rb
@@ -218,7 +226,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -37858944882232104
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -227,6 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
+      hash: 25
       segments: 
       - 1
       - 3
@@ -238,7 +247,7 @@ rubyforge_project: rspec
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: rspec-expectations-2.0.0.beta.22
+summary: rspec-expectations-2.0.0.rc
 test_files: 
 - features/README.markdown
 - features/expectations/attribute_of_subject.feature
@@ -253,7 +262,12 @@ test_files:
 - features/matchers/equality.feature
 - features/matchers/expect_change.feature
 - features/matchers/expect_error.feature
+- features/matchers/have.feature
+- features/matchers/operators.feature
+- features/matchers/predicates.feature
+- features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
+- features/test_frameworks/test_unit.feature
 - spec/rspec/expectations/differ_spec.rb
 - spec/rspec/expectations/extensions/kernel_spec.rb
 - spec/rspec/expectations/fail_with_spec.rb