rspec-expectations 2.4.0 → 2.5.0

data/Guardfile

@@ -1,5 +1,5 @@
 guard 'rspec', :version => 2 do
-  watch('^spec/(.*)_spec.rb')
-  watch('^lib/(.*)\.rb')         { |m| "spec/#{m[1]}_spec.rb" }
-  watch('^spec/spec_helper.rb')  { "spec" }
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^spec\/spec_helper.rb/)  { "spec" }
 end

data/features/.nav

@@ -1,3 +1,4 @@
+- Upgrade.md
 - customized_message.feature
 - diffing.feature
 - implicit_docstrings.feature

data/{History.markdown → features/Changelog.md}

@@ -1,4 +1,13 @@
-## rspec-expectations release history (incomplete)
+### 2.5.0 / 2011-02-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.4.0...v2.5.0)
+
+* Enhancements
+  * `should exist` works with `exist?` or `exists?` (Myron Marston)
+  * `expect { ... }.not_to do_something` (in addition to `to_not`)
+
+* Documentation
+  * improved docs for raise_error matcher (James Almond)
 
 ### 2.4.0 / 2011-01-02
 

data/features/built_in_matchers/exist.feature

@@ -1,11 +1,11 @@
 Feature: exist matcher
 
   The exist matcher is used to specify that something exists
-  (as indicated by #exist?):
+  (as indicated by #exist? or #exists?):
 
-    obj.should exist # passes if obj.exist?
+    obj.should exist # passes if obj.exist? or obj.exists?
 
-  Scenario: basic usage
+  Scenario Outline: basic usage
     Given a file named "exist_matcher_spec.rb" with:
       """
       class Planet
@@ -19,7 +19,7 @@ Feature: exist matcher
           "<Planet: #{name}>"
         end
 
-        def exist?
+        def <predicate_method>
           %w[Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune].include?(name)
         end
       end
@@ -42,3 +42,8 @@ Feature: exist matcher
       | expected <Planet: Earth> not to exist |
       | expected <Planet: Tatooine> to exist  |
 
+    Examples:
+      | predicate_method |
+      | exist?           |
+      | exists?          |
+

data/features/built_in_matchers/expect_change.feature

@@ -1,9 +1,9 @@
 Feature: expect change
 
-  Expect some code (wrapped in a proc) to change the state of some object.
-  
-  Scenario: expecting change
-    Given a file named "expect_change_spec.rb" with:
+  Expect the execution of a block of code to change the state of an object.
+
+  Background:
+    Given a file named "lib/counter.rb" with:
       """
       class Counter
         class << self
@@ -17,49 +17,43 @@ Feature: expect change
           end
         end
       end
-      
+      """
+  
+  Scenario: expect change
+    Given a file named "spec/example_spec.rb" with:
+      """
+      require "counter"
+
       describe Counter, "#increment" do
         it "should increment the count" do
-          expect{Counter.increment}.to change{Counter.count}.from(0).to(1)
+          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)
+          expect { Counter.increment }.to change{Counter.count}.by(2)
         end
       end
       """
-    When I run "rspec ./expect_change_spec.rb"
-    Then the output should contain "2 examples, 1 failure"
+    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: expecting no change
-    Given a file named "expect_no_change_spec.rb" with:
+  Scenario: expect no change
+    Given a file named "spec/example_spec.rb" with:
       """
-      class Counter
-        class << self
-          def increment
-            @count ||= 0
-            @count += 1
-          end
-          
-          def count
-            @count ||= 0
-          end
-        end
-      end
+      require "counter"
 
       describe Counter, "#increment" do
-        it "should not increment the count by 2" do
-          expect{Counter.increment}.to_not change{Counter.count}.from(0).to(2)
+        it "should not increment the count by 1 (using to_not)" do
+          expect { Counter.increment }.to_not change{Counter.count}
         end
 
-        # deliberate failure
-        it "should not increment the count by 1" do
-          expect{Counter.increment}.to_not change{Counter.count}.by(1)
+        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 ./expect_no_change_spec.rb"
-    Then the output should contain "2 examples, 1 failure"
+    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"

data/features/built_in_matchers/expect_error.feature

@@ -1,44 +1,105 @@
-Feature: expect error
+Feature: raise_error matcher
 
-  Expect a proc to raise an error when called.
-  
-  Scenario: expect error
+  Use the `raise_error` matcher to specify that a block of code raises an
+  error. The most basic form passes if any error is thrown:
+
+      expect { raise StandardError }.to raise_error
+
+  You can use `raise_exception` instead if you prefer that wording:
+
+      expect { 3 / 0 }.to raise_exception
+
+  `raise_error` and `raise_exception` are functionally interchangeable, so use
+  the one that makes the most sense to you in any given context.
+
+  In addition to the basic form, above, there are a number of ways to specify
+  details of an error/exception:
+
+  Scenario: expect any error
     Given a file named "expect_error_spec.rb" with:
       """
-      describe Object, "#non_existent_message" do
-        it "should raise" do
-          expect{Object.non_existent_message}.to raise_error(NameError)
+      describe "calling a method that does not exist" do
+        it "raises" do
+          expect { Object.new.foo }.to raise_error
         end
       end
+      """
+    When I run "rspec expect_error_spec.rb"
+    Then the example should pass
 
-      #deliberate failure
-      describe Object, "#public_instance_methods" do
-        it "should raise" do
-          expect{Object.public_instance_methods}.to raise_error(NameError)
+  Scenario: expect specific error
+    Given a file named "expect_error_spec.rb" with:
+      """
+      describe "calling a method that does not exist" do
+        it "raises" do
+          expect { Object.new.foo }.to raise_error(NameError)
         end
       end
       """
-    When I run "rspec ./expect_error_spec.rb"
-    Then the output should contain "2 examples, 1 failure"
-    Then the output should contain "expected NameError but nothing was raised"
+    When I run "rspec expect_error_spec.rb"
+    Then the example should pass
 
-  Scenario: expect no error
-    Given a file named "expect_no_error_spec.rb" with:
+  Scenario: expect specific error message using a string
+    Given a file named "expect_error_with_message.rb" with:
       """
-      describe Object, "#public_instance_methods" do
-        it "should not raise" do
-          expect{Object.public_instance_methods}.to_not raise_error(NameError)
+      describe "matching error message with string" do
+        it "matches the error message" do
+          expect { raise StandardError, 'this message exactly'}.
+            to raise_error(StandardError, 'this message exactly')
+        end
+      end
+      """
+    When I run "rspec expect_error_with_message.rb"
+    Then the example should pass
+
+  Scenario: expect specific error message using a regular expression
+    Given a file named "expect_error_with_regex.rb" with:
+      """
+      describe "matching error message with regex" do
+        it "matches the error message" do
+          expect { raise StandardError, "my message" }.
+            to raise_error(StandardError, /my mess/)
         end
       end
+      """
+    When I run "rspec expect_error_with_regex.rb"
+    Then the example should pass
 
-      #deliberate failure
-      describe Object, "#non_existent_message" do
-        it "should not raise" do
-          expect{Object.non_existent_message}.to_not raise_error(NameError)
+  Scenario: set expectations on error object passed to block
+    Given a file named "expect_error_with_block_spec.rb" with:
+      """
+      describe "#foo" do
+        it "raises NameError" do
+          expect { Object.new.foo }.to raise_error { |error|
+            error.should be_a(NameError)
+          }
         end
       end
       """
-    When I run "rspec ./expect_no_error_spec.rb"
-    Then the output should contain "2 examples, 1 failure"
-    Then the output should contain "undefined method `non_existent_message'"
+      When I run "rspec expect_error_with_block_spec.rb"
+      Then the example should pass
 
+  Scenario: expect no error at all
+    Given a file named "expect_no_error_spec.rb" with:
+      """
+      describe "#to_s" do
+        it "does not raise" do
+          expect { Object.new.to_s }.to_not raise_error
+        end
+      end
+      """
+    When I run "rspec expect_no_error_spec.rb"
+    Then the example should pass
+    
+  Scenario: expect no occurence of a specific error
+    Given a file named "expect_no_error_spec.rb" with:
+      """
+      describe Object, "#public_instance_methods" do
+        it "does not raise" do
+          expect { Object.public_instance_methods }.
+            to_not raise_error(NameError)
+        end
+      end
+      """
+    When I run "rspec expect_no_error_spec.rb"
+    Then the example should pass

data/features/built_in_matchers/include.feature

@@ -118,18 +118,4 @@ Feature: include matcher
       end
       """
     When I run "rspec hash_include_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 22 examples, 13 failures                              |
-      | expected {:a=>7, :b=>5} not to include :a             |
-      | expected {:a=>7, :b=>5} not to include :b and :a      |
-      | expected {:a=>7, :b=>5} not to include {:a=>7}        |
-      | expected {:a=>7, :b=>5} not to include {:a=>7, :b=>5} |
-      | expected {:a=>7, :b=>5} to include :c                 |
-      | expected {:a=>7, :b=>5} to include :c and :d          |
-      | expected {:a=>7, :b=>5} to include {:d=>2}            |
-      | expected {:a=>7, :b=>5} to include {:a=>5}            |
-      | expected {:a=>7, :b=>5} to include {:a=>5, :b=>7}     |
-      | expected {:a=>7, :b=>5} to include :a and :d          |
-      | expected {:a=>7, :b=>5} not to include :a and :d      |
-    And the output should match /expected \{:a=>7, :b=>5\} to include \{(?::a=>7, :d=>3)|(?::d=>3, :a=>7)\}/
-    And the output should match /expected \{:a=>7, :b=>5\} not to include \{(?::a=>7, :d=>3)|(?::d=>3, :a=>7)\}/
+    Then the output should contain "13 failure"

data/features/step_definitions/additional_cli_steps.rb

@@ -11,3 +11,12 @@ Then /^the output should contain all of these:$/ do |table|
   end
 end
 
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  Then %q{the output should contain "0 failures"}
+  Then %q{the exit status should be 0}
+end
+
+Then /^the example should fail$/ do
+  Then %q{the output should contain "1 failure"}
+  Then %q{the exit status should not be 0}
+end

data/lib/rspec/expectations/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Expectations # :nodoc:
     module Version # :nodoc:
-      STRING = '2.4.0'
+      STRING = '2.5.0'
     end
   end
 end

data/lib/rspec/matchers/block_aliases.rb

@@ -3,6 +3,7 @@ module RSpec
     module BlockAliases
       alias_method :to,     :should
       alias_method :to_not, :should_not
+      alias_method :not_to, :should_not
     end
 
     # Extends the submitted block with aliases to and to_not

data/lib/rspec/matchers/exist.rb

@@ -4,11 +4,21 @@ module RSpec
     #   should exist
     #   should_not exist
     #
-    # Passes if actual.exist?
-    def exist(arg=nil)
+    # Passes if actual.exist? or actual.exists?
+    def exist(*args)
       Matcher.new :exist do
         match do |actual|
-          arg ? actual.exist?(arg) : actual.exist?
+          predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
+          existance_values = predicates.map { |p| actual.send(p, *args) }
+          uniq_truthy_values = existance_values.map { |v| !!v }.uniq
+
+          case uniq_truthy_values.size
+            when 0; raise NoMethodError.new("#{actual.inspect} does not respond to either #exist? or #exists?")
+            when 1; existance_values.first
+            else raise "#exist? and #exists? returned different values:\n\n" +
+                       " exist?: #{existance_values.first}\n" +
+                       "exists?: #{existance_values.last}"
+          end
         end
       end
     end

data/spec/rspec/matchers/exist_spec.rb

@@ -1,65 +1,104 @@
 require 'spec_helper'
 
-class Substance
-  def initialize exists, description
-    @exists = exists
-    @description = description
-  end
-  def exist?(arg=nil)
-    @exists
-  end
-  def inspect
-    @description
-  end
-end
-  
-class SubstanceTester
-  include RSpec::Matchers
-  def initialize substance
-    @substance = substance
-  end
-  def should_exist
-    @substance.should exist
-  end
-end
+describe "exist matcher" do
+  context "when the object does not respond to #exist? or #exists?" do
+    subject { mock }
 
-describe "should exist" do
-  
-  before(:each) do
-    @real = Substance.new true, 'something real'
-    @imaginary = Substance.new false, 'something imaginary'
+    [:should, :should_not].each do |should_method|
+      describe "#{should_method} exist" do
+        it "raises an error" do
+          expect {
+            subject.send(should_method, exist)
+          }.to raise_error(NoMethodError)
+        end
+      end
+    end
   end
 
-  describe "within an example group" do
-  
-    it "passes if target exists" do
-      @real.should exist
-    end
-  
-    it "passes if target exists with args" do
-      @real.should exist('this arg')
-    end
-  
-    it "fails if target does not exist" do
-      lambda { @imaginary.should exist }.should fail
-    end
-    
-    it "describes itself" do
-      exist.description.should == "exist"
-    end
-    
-    it "passes should_not exist if target doesn't exist" do
-      lambda { @real.should_not exist }.should fail
+  [:exist?, :exists?].each do |predicate|
+    context "when the object responds to ##{predicate}" do
+      describe "should exist" do
+        it "passes if #{predicate}" do
+          mock(predicate => true).should exist
+        end
+
+        it "fails if not #{predicate}" do
+          expect {
+            mock(predicate => false).should exist
+          }.to fail_with(/expected .* to exist/)
+        end
+      end
+
+      describe "should not exist" do
+        it "passes if not #{predicate}" do
+          mock(predicate => false).should_not exist
+        end
+
+        it "fails if #{predicate}" do
+          expect {
+            mock(predicate => true).should_not exist
+          }.to fail_with(/expected .* not to exist/)
+        end
+      end
     end
   end
 
-  describe "outside of an example group" do
+  context "when the object responds to #exist? and #exists?" do
+    context "when they both return falsey values" do
+      subject { mock(:exist? => false, :exists? => nil) }
+
+      describe "should_not exist" do
+        it "passes" do
+          subject.should_not exist
+        end
+      end
+
+      describe "should exist" do
+        it "fails" do
+          expect {
+            subject.should exist
+          }.to fail_with(/expected .* to exist/)
+        end
+      end
+    end
+
+    context "when they both return truthy values" do
+      subject { mock(:exist? => true, :exists? => "something true") }
+
+      describe "should_not exist" do
+        it "fails" do
+          expect {
+            subject.should_not exist
+          }.to fail_with(/expected .* not to exist/)
+        end
+      end
 
-    it "passes if target exists" do
-      real_tester = SubstanceTester.new @real
-      real_tester.should_exist
+      describe "should exist" do
+        it "passes" do
+          subject.should exist
+        end
+      end
     end
 
+    context "when they return values with different truthiness" do
+      subject { mock(:exist? => true, :exists? => false) }
+
+      [:should, :should_not].each do |should_method|
+        describe "#{should_method} exist" do
+          it "raises an error" do
+            expect {
+              subject.send(should_method, exist)
+            }.to raise_error(/#exist\? and #exists\? returned different values/)
+          end
+        end
+      end
+    end
   end
 
+  it 'passes any provided arguments to the call to #exist?' do
+    object = mock
+    object.should_receive(:exist?).with(:foo, :bar) { true }
+
+    object.should exist(:foo, :bar)
+  end
 end

data/spec/rspec/matchers/include_spec.rb

@@ -142,13 +142,13 @@ describe "should_not include(with, multiple, args)" do
     it "fails if the target includes all of the expected keys" do
       expect {
         { :a => 1, :b => 2 }.should_not include(:a, :b)
-      }.to fail_matching(%Q|expected {:a=>1, :b=>2} not to include :a and :b|)
+      }.to fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include :a and :b|)
     end
 
     it "fails if the target includes some (but not all) of the expected keys" do
       expect {
         { :a => 1, :b => 2 }.should_not include(:d, :b)
-      }.to fail_matching(%Q|expected {:a=>1, :b=>2} not to include :d and :b|)
+      }.to fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include :d and :b|)
     end
   end
 
@@ -218,7 +218,7 @@ describe "should_not include(:key => value)" do
     it "fails if target includes the key/value pair among others" do
       lambda {
         {:key => 'value', :other => 'different'}.should_not include(:key => 'value')
-      }.should fail_matching(%Q|expected {:key=>"value", :other=>"different"} not to include {:key=>"value"}|)
+      }.should fail_matching(%Q|expected #{{:key=>"value", :other=>"different"}.inspect} not to include {:key=>"value"}|)
     end
 
     it "passes if target has a different value for key" do
@@ -256,31 +256,25 @@ describe "should include(:key1 => value1, :key2 => value2)" do
     it "fails if target has a different value for one of the keys" do
       lambda {
         {:a => 1, :b => 2}.should include(:a => 2, :b => 2)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>2} to include {:a=>2, :b=>2}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} to include #{{:a=>2, :b=>2}.inspect}|)
     end
 
     it "fails if target has a different value for both of the keys" do
       lambda {
         {:a => 1, :b => 1}.should include(:a => 2, :b => 2)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>1} to include {:a=>2, :b=>2}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:a=>2, :b=>2}.inspect}|)
     end
 
     it "fails if target lacks one of the keys" do
       lambda {
         {:a => 1, :b => 1}.should include(:a => 1, :c => 1)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>1} to include {:a=>1, :c=>1}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:a=>1, :c=>1}.inspect}|)
     end
 
     it "fails if target lacks both of the keys" do
-      begin
+      lambda {
         {:a => 1, :b => 1}.should include(:c => 1, :d => 1)
-      rescue Exception => e
-      ensure
-        e.message.should match(/expected \{:a=>1, :b=>1\} to include/)
-        e.message.match(/include (.*)$/) do |m|
-          eval(m[1]).should eq({:c=>1,:d=>1})
-        end
-      end
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} to include #{{:c=>1, :d=>1}.inspect}|)
     end
   end
 
@@ -288,7 +282,7 @@ describe "should include(:key1 => value1, :key2 => value2)" do
     it "fails if the target does not contain the given hash" do
       lambda {
         ['a', 'b'].should include(:a => 1, :b => 1)
-      }.should fail_matching(%Q|expected ["a", "b"] to include {:a=>1, :b=>1}|)
+      }.should fail_matching(%Q|expected ["a", "b"] to include #{{:a=>1, :b=>1}.inspect}|)
     end
 
     it "passes if the target contains the given hash" do
@@ -302,20 +296,20 @@ describe "should_not include(:key1 => value1, :key2 => value2)" do
     it "fails if target includes the key/value pairs" do
       lambda {
         {:a => 1, :b => 2}.should_not include(:a => 1, :b => 2)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>2} not to include {:a=>1, :b=>2}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
     end
 
     it "fails if target includes the key/value pairs among others" do
       hash = {:a => 1, :b => 2, :c => 3}
       lambda {
         hash.should_not include(:a => 1, :b => 2)
-      }.should fail_matching(%Q|expected #{hash.inspect} not to include {:a=>1, :b=>2}|)
+      }.should fail_matching(%Q|expected #{hash.inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
     end
 
     it "fails if target has a different value for one of the keys" do
       lambda {
         {:a => 1, :b => 2}.should_not include(:a => 2, :b => 2)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>2} not to include {:a=>2, :b=>2}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>2}.inspect} not to include #{{:a=>2, :b=>2}.inspect}|)
     end
 
     it "passes if target has a different value for both of the keys" do
@@ -325,7 +319,7 @@ describe "should_not include(:key1 => value1, :key2 => value2)" do
     it "fails if target lacks one of the keys" do
       lambda {
         {:a => 1, :b => 1}.should_not include(:a => 1, :c => 1)
-      }.should fail_matching(%Q|expected {:a=>1, :b=>1} not to include {:a=>1, :c=>1}|)
+      }.should fail_matching(%Q|expected #{{:a=>1, :b=>1}.inspect} not to include #{{:a=>1, :c=>1}.inspect}|)
     end
 
     it "passes if target lacks both of the keys" do
@@ -341,7 +335,7 @@ describe "should_not include(:key1 => value1, :key2 => value2)" do
     it "fails if the target contains the given hash" do
       lambda {
         ['a', { :a => 1, :b => 2 } ].should_not include(:a => 1, :b => 2)
-      }.should fail_matching(%Q|expected ["a", {:a=>1, :b=>2}] not to include {:a=>1, :b=>2}|)
+      }.should fail_matching(%Q|expected #{["a", {:a=>1, :b=>2}].inspect} not to include #{{:a=>1, :b=>2}.inspect}|)
     end
   end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-expectations
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 2
-  - 4
+  - 5
   - 0
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors: 
 - David Chelimsky
@@ -15,22 +16,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-02 00:00:00 -06:00
+date: 2011-02-05 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: diff-lcs
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 1
         - 2
         version: 1.1.2
   type: :runtime
+  name: diff-lcs
   prerelease: false
   version_requirements: *id001
 description: rspec expectations (should[_not] and matchers)
@@ -46,14 +48,14 @@ files:
 - .gitignore
 - Gemfile
 - Guardfile
-- History.markdown
 - License.txt
 - README.md
 - Rakefile
-- Upgrade.markdown
 - cucumber.yml
 - features/.nav
+- features/Changelog.md
 - features/README.markdown
+- features/Upgrade.md
 - features/built_in_matchers/be.feature
 - features/built_in_matchers/be_within.feature
 - features/built_in_matchers/equality.feature
@@ -172,7 +174,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2554060302736803438
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -181,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2554060302736803438
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -191,9 +193,11 @@ rubyforge_project: rspec
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: rspec-expectations-2.4.0
+summary: rspec-expectations-2.5.0
 test_files: 
+- features/Changelog.md
 - features/README.markdown
+- features/Upgrade.md
 - features/built_in_matchers/be.feature
 - features/built_in_matchers/be_within.feature
 - features/built_in_matchers/equality.feature