rspec-expectations 2.6.0.rc2 → 2.6.0.rc4

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 
 ### rspec libs
-%w[rspec-core rspec-expectations rspec-mocks].each do |lib|
+%w[rspec rspec-core rspec-expectations rspec-mocks].each do |lib|
   library_path = File.expand_path("../../#{lib}", __FILE__)
   if File.exist?(library_path)
     gem lib, :path => library_path
@@ -12,8 +12,8 @@ end
 
 ### dev dependencies
 gem "rake", "0.8.7"
-# gem "cucumber", "~> 0.10.2"
-# gem "aruba", :git => "git://github.com/aslakhellesoy/aruba"
+gem "cucumber", "~> 0.10.2"
+gem "aruba", "~> 0.3.6"
 gem "rcov", "0.9.9", :platforms => :mri
 gem "relish", "0.2.0"
 gem "guard-rspec", "0.1.9"

data/features/.nav

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

data/features/Changelog.md

@@ -1,6 +1,10 @@
+### 2.6.0.rc4 / 2011-05-01
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.6.0.rc2...v2.6.0.rc4)
+
 ### 2.6.0.rc2 / 2011-04-18
 
-[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.5.0...v2.6.1.rc2)
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.5.0...v2.6.0.rc2)
 
 * Enhancments
   * `change` matcher accepts Regexps (Robert Davis)

data/features/README.markdown

@@ -1,4 +1,4 @@
-rspec-expectations is used to set expectations in executable examples.
+rspec-expectations is used to define expected outcomes.
 
     describe Account do
       it "has a balance of zero when first created" do
@@ -6,14 +6,23 @@ rspec-expectations is used to set expectations in executable examples.
       end
     end
 
-## should and should_not
+## Basic structure
 
-rspec-expectations adds `should` and `should_not` to every object. Each of
-these can accept a matcher and, in most cases, an optional custom failure
-message (see [customized
-message](/rspec/rspec-expectations/v/2-3/customized-message)).
+The basic structure of an rspec expectation is:
 
-## Matchers
+    actual.should matcher(expected)
+    actual.should_not matcher(expected)
+
+## `should` and `should_not`
+
+`rspec-expectations` adds `should` and `should_not` to every object in
+the system. These methods each accept a matcher as an argument. This allows
+each matcher to work in a positive or negative mode:
+
+    5.should eq(5)
+    5.should_not eq(4)
+
+## What is a matcher?
 
 A Matcher is any object that responds to the following methods:
 
@@ -26,10 +35,8 @@ These methods are also part of the matcher protocol, but are optional:
     failure_message_for_should_not
     description
 
-RSpec ships with a number of [built-in
-matchers](/rspec/rspec-expectations/v/2-3/dir/built-in-matchers) and a DSL for
-writing your own [custom
-matchers](/rspec/rspec-expectations/v/2-3/dir/custom-matchers).
+RSpec ships with a number of built-in matchers and a DSL for writing custom
+matchers.
 
 ## Issues
 

data/features/built_in_matchers/README.md

@@ -0,0 +1,67 @@
+## Object identity
+
+    actual.should equal(expected) # passes if actual.equal?(expected)
+    
+## Object equivalence
+
+    actual.should == expected   # passes if actual == expected
+    actual.should eql(expected) # passes if actual.eql?(expected)
+
+## Optional APIs for identity/equivalence
+
+    actual.should eq(expected)  # passes if actual == expected
+    actual.should be(expected)  # passes if actual.equal?(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 anything but nil or false
+    actual.should be_false # passes if actual is nil or false
+    actual.should be_nil   # passes if actual is nil
+    actual.should be       # passes if actual is not nil
+
+## 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?
+
+### Example
+
+    [].should be_empty # passes because [].empty? returns true
+
+## 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")

data/features/built_in_matchers/be_within.feature

@@ -3,17 +3,17 @@ 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 
+      > 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)
+      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.

data/features/built_in_matchers/equality.feature

@@ -2,9 +2,9 @@ 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
+      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
@@ -12,14 +12,17 @@ Feature: equality matchers
 
   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
+      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
+      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:

data/features/built_in_matchers/exist.feature

@@ -5,7 +5,7 @@ Feature: exist matcher
 
     obj.should exist # passes if obj.exist? or obj.exists?
 
-  Scenario Outline: basic usage
+  Scenario: basic usage
     Given a file named "exist_matcher_spec.rb" with:
       """
       class Planet
@@ -19,21 +19,21 @@ Feature: exist matcher
           "<Planet: #{name}>"
         end
 
-        def <predicate_method>
+        def exist? # also works with exists?
           %w[Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune].include?(name)
         end
       end
 
       describe "Earth" do
-        subject { Planet.new("Earth") }
-        it { should exist }
-        it { should_not exist } # deliberate failure
+        let(:earth) { Planet.new("Earth") }
+        specify { earth.should exist }
+        specify { earth.should_not exist } # deliberate failure
       end
 
       describe "Tatooine" do
-        subject { Planet.new("Tatooine") }
-        it { should_not exist }
-        it { should exist } # deliberate failure
+        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`
@@ -41,9 +41,3 @@ Feature: exist matcher
       | 4 examples, 2 failures                |
       | expected <Planet: Earth> not to exist |
       | expected <Planet: Tatooine> to exist  |
-
-    Examples:
-      | predicate_method |
-      | exist?           |
-      | exists?          |
-

data/features/built_in_matchers/predicates.feature

@@ -2,16 +2,16 @@ 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
+      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 ==)"
+      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.
@@ -19,19 +19,19 @@ Feature: predicate matchers
   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)
+      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?
+      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
+      expected zero? to return true, got false
 
   Any arguments passed to the matcher will be passed on to the predicate method.
 

data/lib/rspec/expectations/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Expectations # :nodoc:
     module Version # :nodoc:
-      STRING = '2.6.0.rc2'
+      STRING = '2.6.0.rc4'
     end
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-expectations
 version: !ruby/object:Gem::Version 
-  hash: 15424049
+  hash: 15424061
   prerelease: 6
   segments: 
   - 2
   - 6
   - 0
   - rc
-  - 2
-  version: 2.6.0.rc2
+  - 4
+  version: 2.6.0.rc4
 platform: ruby
 authors: 
 - David Chelimsky
@@ -18,13 +18,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-18 00:00:00 -05:00
+date: 2011-05-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
-  type: :runtime
-  name: diff-lcs
   version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -36,7 +33,10 @@ dependencies:
         - 1
         - 2
         version: 1.1.2
+  prerelease: false
+  type: :runtime
   requirement: *id001
+  name: diff-lcs
 description: rspec expectations (should[_not] and matchers)
 email: dchelimsky@gmail.com;chad.humphries@gmail.com
 executables: []
@@ -59,6 +59,7 @@ files:
 - features/Changelog.md
 - features/README.markdown
 - features/Upgrade.md
+- features/built_in_matchers/README.md
 - features/built_in_matchers/be.feature
 - features/built_in_matchers/be_within.feature
 - features/built_in_matchers/equality.feature
@@ -195,14 +196,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rspec
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: rspec-expectations-2.6.0.rc2
+summary: rspec-expectations-2.6.0.rc4
 test_files: 
 - features/Changelog.md
 - features/README.markdown
 - features/Upgrade.md
+- features/built_in_matchers/README.md
 - features/built_in_matchers/be.feature
 - features/built_in_matchers/be_within.feature
 - features/built_in_matchers/equality.feature