rspec-expectations 2.0.1 → 2.1.0

data/Gemfile

@@ -1,13 +1,14 @@
 source "http://rubygems.org"
 
+%w[rspec-core rspec-expectations rspec-mocks].each do |lib|
+  gem lib, :path => File.expand_path("../../#{lib}", __FILE__)
+end
+
 gem "rake"
-gem "cucumber"
-gem "aruba", ">= 0.2.0"
+gem "cucumber", "0.8.5"
+gem "aruba", "0.2.2"
 gem "autotest"
 gem "diff-lcs"
-gem "rspec-expectations", :path => "."
-gem "rspec-core", :path => "../rspec-core"
-gem "rspec-mocks", :path => "../rspec-mocks"
 gem "watchr"
 gem "rcov"
 gem "relish"

data/History.markdown

@@ -1,11 +1,21 @@
 ## rspec-expectations release history (incomplete)
 
-### 2.0.1 / 2010-10-18
+### 2.1.0 / 2010-11-07
 
-[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0...v2.0.1)
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.1...v2.1.0)
 
 * Enhancements
-  * Make dependencies on other rspec gems consistent across gems
+  * be_within(delta).of(expected) matcher (Myron Marston)
+  * Lots of new Cucumber features (Myron Marston)
+  * Raise error if you try "should != expected" on Ruby-1.9 (Myron Marston)
+  * Improved failure messages from throw_symbol (Myron Marston)
+
+* Bug fixes
+  * Eliminate hard dependency on RSpec::Core (Myron Marston)
+  * have_matcher - use pluralize only when ActiveSupport inflections are indeed
+    defined (Josep M Bach)
+  * throw_symbol matcher no longer swallows exceptions (Myron Marston)
+  * fix matcher chaining to avoid name collisions (Myron Marston)
 
 ### 2.0.0 / 2010-10-10
 

data/README.markdown

@@ -3,6 +3,16 @@
 rspec-expectations adds `should` and `should_not` to every object and includes
 RSpec::Matchers, a library of standard matchers.
 
+## Documentation
+
+* [Cucumber features](http://relishapp.com/rspec/rspec-expectations/v/2-0)
+* [RDoc](http://rubydoc.info/gems/rspec-expectations/2.0.1/frames)
+
+## Install
+
+    gem install rspec               # for rspec-core, rspec-expectations, rspec-mocks
+    gem install rspec-expecctations # for rspec-core only
+
 ## Matchers
 
 Matchers are objects used to compose expectations:

data/Rakefile

@@ -58,7 +58,7 @@ end
 desc "Push cukes to relishapp using the relish-client-gem"
 task :relish, :version do |t, args|
   raise "rake relish[VERSION]" unless args[:version]
-  sh "bundle exec relish --organization rspec --project rspec-expectations -v #{args[:version]} push"
+  sh "bundle exec relish push --organization rspec --project rspec-expectations -v #{args[:version]}"
 end
 
 task :clobber do

data/features/matchers/be_within.feature

@@ -0,0 +1,43 @@
+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:
+      """
+      describe 27.5 do
+        it { should be_within(0.5).of(27.9) }
+        it { should be_within(0.5).of(27.1) }
+        it { should_not be_within(0.5).of(28) }
+        it { should_not be_within(0.5).of(27) }
+
+        # deliberate failures
+        it { should_not be_within(0.5).of(27.9) }
+        it { should_not be_within(0.5).of(27.1) }
+        it { should be_within(0.5).of(28) }
+        it { should be_within(0.5).of(27) }
+      end
+      """
+    When I run "rspec be_within_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 27.9 |
+      | expected 27.5 not to be within 0.5 of 27.1 |
+      | expected 27.5 to be within 0.5 of 28       |
+      | expected 27.5 to be within 0.5 of 27       |

data/features/matchers/exist.feature

@@ -0,0 +1,44 @@
+Feature: exist matcher
+
+  The exist matcher is used to specify that something exists
+  (as indicated by #exist?):
+
+    obj.should exist # passes if obj.exist?
+
+  Scenario: basic usage
+    Given a file named "exist_matcher_spec.rb" with:
+      """
+      class Planet
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def inspect
+          "<Planet: #{name}>"
+        end
+
+        def exist?
+          %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
+      end
+
+      describe "Tatooine" do
+        subject { Planet.new("Tatooine") }
+        it { should_not exist }
+        it { should exist } # deliberate failure
+      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/features/matchers/include.feature

@@ -1,6 +1,6 @@
 Feature: include matcher
 
-  Use the include matcher to specify than a collection includes one or more
+  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):
 

data/features/matchers/respond_to.feature

@@ -6,7 +6,7 @@ Feature: respond_to matcher
     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
+  statement with multiple arguments passed to the matcher:
     
     obj.should respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
 

data/features/matchers/satisfy.feature

@@ -0,0 +1,31 @@
+Feature: Satisfy matcher
+
+  The satisfy matcher is extremely flexible and can handle almost anything
+  you want to specify.  It passes if the block you provide returns true:
+
+    10.should satisfy { |v| v % 5 == 0 }
+    7.should_not satisfy { |v| v % 5 == 0 }
+
+  This flexibility comes at a cost, however: the failure message
+  ("expected [actual] to satisfy block") is not very descriptive
+  or helpful.  You will usually be better served by using one of
+  the other built-in matchers, or writing a custom matcher.
+
+  Scenario: basic usage
+    Given a file named "satisfy_matcher_spec.rb" with:
+      """
+      describe 10 do
+        it { should satisfy { |v| v > 5 } }
+        it { should_not satisfy { |v| v > 15 } }
+
+        # deliberate failures
+        it { should_not satisfy { |v| v > 5 } }
+        it { should satisfy { |v| v > 15 } }
+      end
+      """
+    When I run "rspec satisfy_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 4 examples, 2 failures           |
+      | expected 10 not to satisfy block |
+      | expected 10 to satisfy block     |
+

data/features/matchers/throw_symbol.feature

@@ -0,0 +1,85 @@
+Feature: Throw symbol matcher
+
+  The throw_symbol matcher is used to specify that a block of code
+  throws a symbol.  The most basic form passes if any symbol is thrown:
+
+    expect { throw :foo }.to throw_symbol
+
+  You'll often want to specify that a particular symbol is thrown:
+
+    expect { throw :foo }.to throw_symbol(:foo)
+
+  If you care about the additional argument given to throw, you can
+  specify that as well:
+
+    expect { throw :foo, 7 }.to throw_symbol(:foo, 7)
+
+  Scenario: basic usage
+    Given a file named "throw_symbol_matcher_spec.rb" with:
+      """
+      describe "throw" do
+        specify { expect { throw :foo    }.to     throw_symbol }
+        specify { expect { throw :bar, 7 }.to     throw_symbol }
+        specify { expect { 5 + 5         }.to_not throw_symbol }
+
+        # deliberate failures
+        specify { expect { throw :foo    }.to_not throw_symbol }
+        specify { expect { throw :bar, 7 }.to_not throw_symbol }
+        specify { expect { 5 + 5         }.to     throw_symbol }
+      end
+      """
+    When I run "rspec throw_symbol_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                      |
+      | expected no Symbol to be thrown, got :foo   |
+      | expected no Symbol to be thrown, got :bar   |
+      | expected a Symbol to be thrown, got nothing |
+
+  Scenario: specify thrown symbol
+    Given a file named "throw_symbol_matcher_spec.rb" with:
+      """
+      describe "throw symbol" do
+        specify { expect { throw :foo    }.to     throw_symbol(:foo) }
+        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo) }
+        specify { expect { 5 + 5         }.to_not throw_symbol(:foo) }
+        specify { expect { throw :bar    }.to_not throw_symbol(:foo) }
+
+        # deliberate failures
+        specify { expect { throw :foo    }.to_not throw_symbol(:foo) }
+        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo) }
+        specify { expect { 5 + 5         }.to     throw_symbol(:foo) }
+        specify { expect { throw :bar    }.to     throw_symbol(:foo) }
+      end
+      """
+    When I run "rspec throw_symbol_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                          |
+      | expected :foo not to be thrown, got :foo        |
+      | expected :foo not to be thrown, got :foo with 7 |
+      | expected :foo to be thrown, got nothing         |
+      | expected :foo to be thrown, got :bar            |
+
+  Scenario: specify thrown symbol and argument
+    Given a file named "throw_symbol_argument_matcher_spec.rb" with:
+      """
+      describe "throw symbol with argument" do
+        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 8 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :bar, 7 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo    }.to_not throw_symbol(:foo, 7) }
+
+        # deliberate failures
+        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 8 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :bar, 7 }.to     throw_symbol(:foo, 7) }
+        specify { expect { throw :foo    }.to     throw_symbol(:foo, 7) }
+      end
+      """
+    When I run "rspec throw_symbol_argument_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                       |
+      | expected :foo with 7 not to be thrown, got :foo with 7       |
+      | expected :foo with 7 to be thrown, got :foo with 8           |
+      | expected :foo with 7 to be thrown, got :bar                  |
+      | expected :foo with 7 to be thrown, got :foo with no argument |
+

data/features/matchers/types.feature

@@ -1,6 +1,6 @@
-Feature: Type Check matchers
+Feature: specify types of objects
 
-  rspec-expectations includes two matchers specify types of objects:
+  rspec-expectations includes two matchers to specify types of objects:
 
     * obj.should be_kind_of(type): calls obj.kind_of?(type), which returns
       true if type is in obj's class hierarchy or is a module and is

data/features/test_frameworks/test_unit.feature

@@ -31,12 +31,16 @@ Feature: Test::Unit integration
           array.should be_empty
         end
 
+        def test_expect_matcher
+          expect { @a = 5 }.to change { @a }.from(nil).to(5)
+        end
+
         def test_custom_matcher_and_deprecation_warning
           1.should be_an_int
         end
       end
       """
      When I run "ruby rspec_expectations_test.rb"
-     Then the output should contain "3 tests, 0 assertions, 1 failures, 0 errors" or "3 tests, 0 assertions, 0 failures, 1 errors"
+     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 errors"
       And the output should contain "expected empty? to return true, got false"
       And the output should contain "be_an_int is deprecated"

data/lib/rspec/expectations.rb

@@ -1,8 +1,8 @@
+require 'rspec/expectations/extensions'
 require 'rspec/matchers'
 require 'rspec/expectations/fail_with'
 require 'rspec/expectations/errors'
 require 'rspec/expectations/deprecation'
-require 'rspec/expectations/extensions'
 require 'rspec/expectations/handler'
 require 'rspec/expectations/version'
 require 'rspec/expectations/backward_compatibility'

data/lib/rspec/expectations/extensions.rb

@@ -1,3 +1,2 @@
 require 'rspec/expectations/extensions/kernel'
 require 'rspec/expectations/extensions/array'
-require 'rspec/expectations/extensions/rspec/core/example_group'

data/lib/rspec/expectations/version.rb

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

data/lib/rspec/matchers.rb

@@ -155,10 +155,6 @@ module RSpec
   #   end
   #
   module Matchers
-    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)
@@ -177,6 +173,8 @@ require 'rspec/matchers/be'
 require 'rspec/matchers/be_close'
 require 'rspec/matchers/be_instance_of'
 require 'rspec/matchers/be_kind_of'
+require 'rspec/matchers/be_within'
+require 'rspec/matchers/block_aliases'
 require 'rspec/matchers/change'
 require 'rspec/matchers/eq'
 require 'rspec/matchers/eql'

data/lib/rspec/matchers/be_close.rb

@@ -10,23 +10,8 @@ module RSpec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      Matcher.new :be_close, expected, delta do |_expected_, _delta_|
-        match do |actual|
-          (actual - _expected_).abs < _delta_
-        end
-
-        failure_message_for_should do |actual|
-          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
-        end
-
-        failure_message_for_should_not do |actual|
-          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
-        end
-
-        description do
-          "be close to #{_expected_} (within +- #{_delta_})"
-        end
-      end
+      RSpec.deprecate("be_close(#{expected}, #{delta})", "be_within(#{delta}).of(#{expected})")
+      be_within(delta).of(expected)
     end
   end
 end

data/lib/rspec/matchers/be_within.rb

@@ -0,0 +1,40 @@
+module RSpec
+  module Matchers
+    # :call-seq:
+    #   should be_within(delta).of(expected)
+    #   should_not be_within(delta).of(expected)
+    #
+    # Passes if actual == expected +/- delta
+    #
+    # == Example
+    #
+    #   result.should be_within(0.5).of(3.0)
+    def be_within(delta)
+      Matcher.new :be_within, delta do |_delta_|
+        chain :of do |_expected_|
+          @_expected = _expected_
+        end
+
+        match do |actual|
+          unless @_expected
+            raise ArgumentError.new("You must set an expected value using #of: be_within(#{_delta_}).of(expected_value)")
+          end
+          (actual - @_expected).abs < _delta_
+        end
+
+        failure_message_for_should do |actual|
+          "expected #{actual} to #{description}"
+        end
+
+        failure_message_for_should_not do |actual|
+          "expected #{actual} not to #{description}"
+        end
+
+        description do
+          "be within #{_delta_} of #{@_expected}"
+        end
+      end
+    end
+  end
+end
+

data/lib/rspec/matchers/block_aliases.rb

@@ -0,0 +1,18 @@
+module RSpec
+  module Matchers
+    module BlockAliases
+      alias_method :to,     :should
+      alias_method :to_not, :should_not
+    end
+
+    # Extends the submitted block with aliases to and to_not
+    # for should and should_not. Allows expectations like this:
+    #
+    #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
+    #   expect { this_block }.to raise_error
+    def expect(&block)
+      block.extend BlockAliases
+    end
+  end
+end
+

data/lib/rspec/matchers/have.rb

@@ -4,7 +4,7 @@ module RSpec
       def initialize(expected, relativity=:exactly)
         @expected = (expected == :no ? 0 : expected)
         @relativity = relativity
-        @actual = nil
+        @actual = @collection_name = @plural_collection_name = nil
       end
     
       def relativities
@@ -75,7 +75,7 @@ EOF
       
       def method_missing(sym, *args, &block)
         @collection_name = sym
-        if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+        if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
           @plural_collection_name = inflector.pluralize(sym.to_s)
         end
         @args = args

data/lib/rspec/matchers/matcher.rb

@@ -11,7 +11,9 @@ module RSpec
         @expected = expected
         @actual   = nil
         @diffable = false
-        @expected_exception, @rescued_exception = nil
+        @expected_exception, @rescued_exception = nil, nil
+        @match_for_should_not_block = nil
+
         @messages = {
           :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
           :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
@@ -97,11 +99,9 @@ module RSpec
       
       # See RSpec::Matchers
       def chain(method, &block)
-        self.class.class_eval do
-          define_method method do |*args|
-            block.call(*args)
-            self
-          end
+        define_method method do |*args|
+          block.call(*args)
+          self
         end
       end
       

data/lib/rspec/matchers/operator_matcher.rb

@@ -29,6 +29,15 @@ module RSpec
             eval_match(@actual, operator, expected)
           end
         end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+                  "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
       end
 
       ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|

data/lib/rspec/matchers/throw_symbol.rb

@@ -19,42 +19,45 @@ module RSpec
                 throw :proc_did_not_throw_anything, :nothing_thrown
               end
             end
-            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+
+            if @caught_arg == :nothing_thrown
+              @caught_arg = nil
+            else
+              @caught_symbol = @expected_symbol
+            end
           end
 
         # Ruby 1.8 uses NameError with `symbol'
         # Ruby 1.9 uses ArgumentError with :symbol
         rescue NameError, ArgumentError => e
-          raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+          unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+            other_exception = e
+            raise
+          end
           @caught_symbol = $2.to_sym
-
+        rescue => other_exception
+          raise
         ensure
-          if @expected_symbol.nil?
-            return !@caught_symbol.nil?
-          else
-            if @expected_arg.nil?
-              return @caught_symbol == @expected_symbol
+          unless other_exception
+            if @expected_symbol.nil?
+              return !@caught_symbol.nil?
             else
-              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+              if @expected_arg.nil?
+                return @caught_symbol == @expected_symbol
+              else
+                return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+              end
             end
           end
         end
       end
 
       def failure_message_for_should
-        if @caught_symbol
-          "expected #{expected}, got #{@caught_symbol.inspect}"
-        else
-          "expected #{expected} but nothing was thrown"
-        end
+        "expected #{expected} to be thrown, got #{caught}"
       end
       
       def failure_message_for_should_not
-        if @expected_symbol
-          "expected #{expected} not to be thrown"
-        else
-          "expected no Symbol, got :#{@caught_symbol}"
-        end
+        "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
       end
       
       def description
@@ -62,15 +65,29 @@ module RSpec
       end
       
       private
-      
-        def expected
-          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
         end
-        
-        def args
-          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
         end
-      
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+            " with #{arg.inspect}"
+          elsif @expected_arg && @caught_symbol == @expected_symbol
+            " with no argument"
+          else
+            ""
+          end
+
+          symbol_description + arg_description
+        end
+
     end
  
     # :call-seq:

data/rspec-expectations.gemspec

@@ -22,10 +22,6 @@ Gem::Specification.new do |s|
   s.rdoc_options     = ["--charset=UTF-8"]
   s.require_path     = "lib"
 
-  s.add_runtime_dependency     'diff-lcs',    '>= 1.1.2'
-  s.add_development_dependency 'cucumber',    ">= 0.6.2"
-  s.add_development_dependency 'aruba',       ">= 0.1.1"
-  s.add_development_dependency 'rspec-core',  "~> 2.0.1"
-  s.add_development_dependency 'rspec-mocks', "~> 2.0.1"
+  s.add_runtime_dependency     'diff-lcs',    '~> 1.1.2'
 end
 

data/spec/rspec/matchers/be_close_spec.rb

@@ -1,49 +1,21 @@
 require 'spec_helper'
+
 module RSpec
   module Matchers
     describe "[actual.should] be_close(expected, delta)" do
-      it "matches when actual == expected" do
-        be_close(5.0, 0.5).matches?(5.0).should be_true
-      end
-      it "matches when actual < (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.49).should be_true
-      end
-      it "matches when actual > (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.51).should be_true
-      end
-      it "does not match when actual == (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.5).should be_false
-      end
-      it "does not match when actual < (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.49).should be_false
-      end
-      it "does not match when actual == (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.5).should be_false
-      end
-      it "does not match when actual > (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.51).should be_false
-      end
-      it "provides a failure message for should" do
-        #given
-          matcher = be_close(5.0, 0.5)
-        #when
-          matcher.matches?(5.51)
-        #then
-          matcher.failure_message_for_should.should == "expected 5.0 +/- (< 0.5), got 5.51"
+      before(:each) do
+        RSpec.stub(:warn)
       end
 
-      it "provides a failure message for should tno" do
-        #given
-          matcher = be_close(5.0, 0.5)
-        #when
-          matcher.matches?(5.49)
-        #then
-          matcher.failure_message_for_should_not.should == "expected 5.0 +/- (< 0.5), got 5.49"
+      it "delegates to be_within(delta).of(expected)" do
+        should_receive(:be_within).with(0.5).and_return( be_within_matcher = stub )
+        be_within_matcher.should_receive(:of).with(3.0)
+        be_close(3.0, 0.5)
       end
-      it "provides a description" do
-        matcher = be_close(5.0, 0.5)
-        matcher.matches?(5.1)
-        matcher.description.should == "be close to 5.0 (within +- 0.5)"
+
+      it "prints a deprecation warning" do
+        RSpec.should_receive(:warn).with(/please use be_within.*instead/)
+        be_close(3.0, 0.5)
       end
     end
   end

data/spec/rspec/matchers/be_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe "should be_predicate" do  
+  it "allows other undefined methods to raise errors as normal" do
+    expect { some_undefined_method }.to raise_error(NameError)
+  end
+
   it "passes when actual returns true for :predicate?" do
     actual = stub("actual", :happy? => true)
     actual.should be_happy

data/spec/rspec/matchers/be_within_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    describe "[actual.should] be_within(delta).of(expected)" do
+      it "matches when actual == expected" do
+        be_within(0.5).of(5.0).matches?(5.0).should be_true
+      end
+
+      it "matches when actual < (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.49).should be_true
+      end
+
+      it "matches when actual > (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.51).should be_true
+      end
+
+      it "does not match when actual == (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.5).should be_false
+      end
+
+      it "does not match when actual < (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.49).should be_false
+      end
+
+      it "does not match when actual == (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.5).should be_false
+      end
+
+      it "does not match when actual > (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.51).should be_false
+      end
+
+      it "provides a failure message for should" do
+        #given
+          matcher = be_within(0.5).of(5.0)
+        #when
+          matcher.matches?(5.51)
+        #then
+          matcher.failure_message_for_should.should == "expected 5.51 to be within 0.5 of 5.0"
+      end
+
+      it "provides a failure message for should not" do
+        #given
+          matcher = be_within(0.5).of(5.0)
+        #when
+          matcher.matches?(5.49)
+        #then
+          matcher.failure_message_for_should_not.should == "expected 5.49 not to be within 0.5 of 5.0"
+      end
+
+      it "provides a description" do
+        matcher = be_within(0.5).of(5.0)
+        matcher.matches?(5.1)
+        matcher.description.should == "be within 0.5 of 5.0"
+      end
+
+      it "raises an error if no expected value is given" do
+        matcher = be_within(0.5)
+        expect { matcher.matches?(5.1) }.to raise_error(ArgumentError, /must set an expected value using #of/)
+      end
+    end
+  end
+end

data/spec/rspec/matchers/have_spec.rb

@@ -4,7 +4,7 @@ require 'stringio'
 describe "have matcher" do
 
   before(:each) do
-    if defined?(::ActiveSupport::Inflector)
+    if defined?(::ActiveSupport::Inflector) && ::ActiveSupport::Inflector.respond_to?(:pluralize)
       @active_support_was_defined = true
     else
       @active_support_was_defined = false
@@ -68,6 +68,16 @@ describe 'should have(1).item when ActiveSupport::Inflector is defined' do
     owner = create_collection_owner_with(1)
     owner.should have(1).item
   end
+
+  context "when ActiveSupport::Inflector is partially loaded without its inflectors" do
+
+    it "does not pluralize the collection name" do
+      (class << ::ActiveSupport::Inflector; self; end).send :undef_method, :pluralize
+      owner = create_collection_owner_with(1)
+      expect { owner.should have(1).item }.to raise_error(NoMethodError)
+    end
+
+  end
   
   after(:each) do
     unless @active_support_was_defined

data/spec/rspec/matchers/matcher_spec.rb

@@ -334,6 +334,14 @@ module RSpec
         matcher.expecting('value').matches?('other value').should be_false
       end
 
+      it "prevents name collisions on chainable methods from different matchers" do
+        m1 = RSpec::Matchers::Matcher.new(:m1) { chain(:foo) { raise "foo in m1" } }
+        m2 = RSpec::Matchers::Matcher.new(:m2) { chain(:foo) { raise "foo in m2" } }
+
+        expect { m1.foo }.to raise_error("foo in m1")
+        expect { m2.foo }.to raise_error("foo in m2")
+      end
+
       context "defined using the dsl" do
         def a_method_in_the_example
           "method defined in the example"

data/spec/rspec/matchers/operator_matcher_spec.rb

@@ -21,6 +21,32 @@ describe "should ==" do
   
 end
 
+describe "unsupported operators", :ruby => '1.9' do
+  it "raises an appropriate error for should != expected" do
+    expect {
+      "apple".should != "pear"
+    }.to raise_error(/does not support `should != expected`.  Use `should_not == expected`/)
+  end
+
+  it "raises an appropriate error for should_not != expected" do
+    expect {
+      "apple".should_not != "pear"
+    }.to raise_error(/does not support `should_not != expected`.  Use `should == expected`/)
+  end
+
+  it "raises an appropriate error for should !~ expected" do
+    expect {
+      "apple".should !~ /regex/
+    }.to raise_error(/does not support `should !~ expected`.  Use `should_not =~ expected`/)
+  end
+
+  it "raises an appropriate error for should_not !~ expected" do
+    expect {
+      "apple".should_not !~ /regex/
+    }.to raise_error(/does not support `should_not !~ expected`.  Use `should =~ expected`/)
+  end
+end
+
 describe "should_not ==" do
   
   it "delegates message to target" do

data/spec/rspec/matchers/throw_symbol_spec.rb

@@ -17,11 +17,11 @@ module RSpec
         end
         it "provides a failure message" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown"
+          @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym})
-          @matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym"
+          @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
         end
       end
           
@@ -42,18 +42,20 @@ module RSpec
         end
         it "provides a failure message when no Symbol is thrown" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected :sym but nothing was thrown"
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
         end
         it "provides a failure message when wrong Symbol is thrown" do
           @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == "expected :sym, got :other_sym"
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown"
+          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
         end
         it "only matches NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
         end
       end
 
@@ -77,18 +79,33 @@ module RSpec
         end
         it "provides a failure message when no Symbol is thrown" do
           @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown]
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
         end
         it "provides a failure message when wrong Symbol is thrown" do
           @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym]
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
+        end
+        it "provides a failure message when wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
+        end
+        it "provides a failure message when no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
         end
         it "provides a negative failure message" do
           @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown]
+          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
         end
         it "only matches NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
+        end
+        it "raises other errors" do
+          expect {
+            @matcher.matches?(lambda { raise "Boom" })
+          }.to raise_error(/Boom/)
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 def add_to_load_path(path, prepend=false)
-  path = File.expand_path("../#{path}", __FILE__)
+  path = File.expand_path("../../#{path}/lib", __FILE__)
   if prepend
     $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
   else
@@ -7,10 +7,11 @@ def add_to_load_path(path, prepend=false)
   end
 end
 
-add_to_load_path("../lib", :prepend)
-add_to_load_path("../../rspec-core/lib")
-add_to_load_path("../../rspec-mocks/lib")
+add_to_load_path("rspec-expectations", :prepend)
+add_to_load_path("rspec-core")
+add_to_load_path("rspec-mocks")
 
+require 'rspec/expectations'
 require 'rspec/core'
 require 'rspec/mocks'
 
@@ -49,5 +50,17 @@ RSpec::configure do |config|
   config.include RSpec::Mocks::Methods
   config.color_enabled = true
   config.filter_run :focused => true
+
+  config.filter_run_excluding :ruby => lambda {|version|
+    case version.to_s
+    when "!jruby"
+      RUBY_ENGINE != "jruby"
+    when /^> (.*)/
+      !(RUBY_VERSION.to_s > $1)
+    else
+      !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+    end
+  }
+
   config.run_all_when_everything_filtered = true
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-expectations
 version: !ruby/object:Gem::Version 
-  hash: 13
   prerelease: false
   segments: 
   - 2
-  - 0
   - 1
-  version: 2.0.1
+  - 0
+  version: 2.1.0
 platform: ruby
 authors: 
 - David Chelimsky
@@ -16,89 +15,24 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 -05:00
+date: 2010-11-07 01:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  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
-  requirement: *id001
   type: :runtime
-  name: diff-lcs
-  prerelease: false
-- !ruby/object:Gem::Dependency 
-  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
-- !ruby/object:Gem::Dependency 
-  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
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 2
-        - 0
-        - 1
-        version: 2.0.1
-  requirement: *id004
-  type: :development
-  name: rspec-core
-  prerelease: false
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 2
-        - 0
-        - 1
-        version: 2.0.1
-  requirement: *id005
-  type: :development
-  name: rspec-mocks
   prerelease: false
+  version_requirements: *id001
 description: rspec expectations (should[_not] and matchers)
 email: dchelimsky@gmail.com;chad.humphries@gmail.com
 executables: []
@@ -123,11 +57,13 @@ files:
 - features/expectations/diffing.feature
 - features/expectations/implicit_docstrings.feature
 - features/matchers/access_running_example.feature
+- features/matchers/be_within.feature
 - features/matchers/define_diffable_matcher.feature
 - features/matchers/define_matcher.feature
 - features/matchers/define_matcher_outside_rspec.feature
 - features/matchers/define_matcher_with_fluent_interface.feature
 - features/matchers/equality.feature
+- features/matchers/exist.feature
 - features/matchers/expect_change.feature
 - features/matchers/expect_error.feature
 - features/matchers/have.feature
@@ -135,6 +71,8 @@ files:
 - features/matchers/operators.feature
 - features/matchers/predicates.feature
 - features/matchers/respond_to.feature
+- features/matchers/satisfy.feature
+- features/matchers/throw_symbol.feature
 - features/matchers/types.feature
 - features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
@@ -148,7 +86,6 @@ files:
 - lib/rspec/expectations/extensions.rb
 - lib/rspec/expectations/extensions/array.rb
 - lib/rspec/expectations/extensions/kernel.rb
-- lib/rspec/expectations/extensions/rspec/core/example_group.rb
 - lib/rspec/expectations/fail_with.rb
 - lib/rspec/expectations/handler.rb
 - lib/rspec/expectations/version.rb
@@ -157,6 +94,8 @@ files:
 - lib/rspec/matchers/be_close.rb
 - lib/rspec/matchers/be_instance_of.rb
 - lib/rspec/matchers/be_kind_of.rb
+- lib/rspec/matchers/be_within.rb
+- lib/rspec/matchers/block_aliases.rb
 - lib/rspec/matchers/change.rb
 - lib/rspec/matchers/compatibility.rb
 - lib/rspec/matchers/dsl.rb
@@ -189,6 +128,7 @@ files:
 - spec/rspec/matchers/be_instance_of_spec.rb
 - spec/rspec/matchers/be_kind_of_spec.rb
 - spec/rspec/matchers/be_spec.rb
+- spec/rspec/matchers/be_within_spec.rb
 - spec/rspec/matchers/change_spec.rb
 - spec/rspec/matchers/compatibility_spec.rb
 - spec/rspec/matchers/description_generation_spec.rb
@@ -227,7 +167,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -1883027973330642761
       segments: 
       - 0
       version: "0"
@@ -236,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -1883027973330642761
       segments: 
       - 0
       version: "0"
@@ -246,7 +186,7 @@ rubyforge_project: rspec
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: rspec-expectations-2.0.1
+summary: rspec-expectations-2.1.0
 test_files: 
 - features/README.markdown
 - features/expectations/attribute_of_subject.feature
@@ -254,11 +194,13 @@ test_files:
 - features/expectations/diffing.feature
 - features/expectations/implicit_docstrings.feature
 - features/matchers/access_running_example.feature
+- features/matchers/be_within.feature
 - features/matchers/define_diffable_matcher.feature
 - features/matchers/define_matcher.feature
 - features/matchers/define_matcher_outside_rspec.feature
 - features/matchers/define_matcher_with_fluent_interface.feature
 - features/matchers/equality.feature
+- features/matchers/exist.feature
 - features/matchers/expect_change.feature
 - features/matchers/expect_error.feature
 - features/matchers/have.feature
@@ -266,6 +208,8 @@ test_files:
 - features/matchers/operators.feature
 - features/matchers/predicates.feature
 - features/matchers/respond_to.feature
+- features/matchers/satisfy.feature
+- features/matchers/throw_symbol.feature
 - features/matchers/types.feature
 - features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
@@ -278,6 +222,7 @@ test_files:
 - spec/rspec/matchers/be_instance_of_spec.rb
 - spec/rspec/matchers/be_kind_of_spec.rb
 - spec/rspec/matchers/be_spec.rb
+- spec/rspec/matchers/be_within_spec.rb
 - spec/rspec/matchers/change_spec.rb
 - spec/rspec/matchers/compatibility_spec.rb
 - spec/rspec/matchers/description_generation_spec.rb

data/lib/rspec/expectations/extensions/rspec/core/example_group.rb

@@ -1,19 +0,0 @@
-module RSpec
-  module Core
-    class ExampleGroup
-      module BlockAliases
-        alias_method :to,     :should
-        alias_method :to_not, :should_not
-      end
-
-      # Extends the submitted block with aliases to and to_not
-      # for should and should_not. Allows expectations like this:
-      #
-      #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
-      #   expect { this_block }.to raise_error
-      def expect(&block)
-        block.extend BlockAliases
-      end
-    end
-  end
-end