rspec-expectations 2.8.0.rc1 → 2.8.0.rc2

data/License.txt

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+Copyright (c) 2005 Steven Baker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -22,19 +22,21 @@ Minitest, or Cucumber, you can install it directly:
 
 Here's an example using rspec-core:
 
-    describe Order do
-      it "sums the prices of the items in its line items" do
-        order = Order.new
-        order.add_entry(LineItem.new(:item => Item.new(
-          :price => Money.new(1.11, :USD)
-        )
-        order.add_entry(LineItem.new(:item => Item.new(
-          :price => Money.new(2.22, :USD),
-          :quantity => 2
-        )
-        order.total.should eq(Money.new(5.55, :USD))
-      end
-    end
+```ruby
+describe Order do
+  it "sums the prices of the items in its line items" do
+    order = Order.new
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(1.11, :USD)
+    )))
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(2.22, :USD),
+      :quantity => 2
+    )))
+    order.total.should eq(Money.new(5.55, :USD))
+  end
+end
+```
 
 The `describe` and `it` methods come from rspec-core.  The `Order`, `LineItem`,
 and `Item` classes would be from _your_ code. The last line of the example
@@ -48,73 +50,97 @@ the example passes. If not, it fails with a message like:
 
 ### Equivalence
 
-    actual.should eq(expected)  # passes if actual == expected
-    actual.should == expected   # passes if actual == expected
-    actual.should eql(expected) # passes if actual.eql?(expected)
+```ruby
+actual.should eq(expected)  # passes if actual == expected
+actual.should == expected   # passes if actual == expected
+actual.should eql(expected) # passes if actual.eql?(expected)
+```
 
 ### Identity
 
-    actual.should be(expected)    # passes if actual.equal?(expected)
-    actual.should equal(expected) # passes if actual.equal?(expected)
+```ruby
+actual.should be(expected)    # passes if actual.equal?(expected)
+actual.should equal(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 be_within(delta).of(expected)
+```ruby
+actual.should be >  expected
+actual.should be >= expected
+actual.should be <= expected
+actual.should be <  expected
+actual.should be_within(delta).of(expected)
+```
 
 ### Regular expressions
 
-    actual.should =~ /expression/
-    actual.should match(/expression/)
+```ruby
+actual.should =~ /expression/
+actual.should match(/expression/)
+```
 
 ### Types/classes
 
-    actual.should be_an_instance_of(expected)
-    actual.should be_a_kind_of(expected)
+```ruby
+actual.should be_an_instance_of(expected)
+actual.should be_a_kind_of(expected)
+```
 
 ### Truthiness
 
-    actual.should be_true  # passes if actual is truthy (not nil or false)
-    actual.should be_false # passes if actual is falsy (nil or false)
-    actual.should be_nil   # passes if actual is nil
+```ruby
+actual.should be_true  # passes if actual is truthy (not nil or false)
+actual.should be_false # passes if actual is falsy (nil or false)
+actual.should be_nil   # passes if actual is nil
+```
 
 ### Expecting errors
 
-    expect { ... }.to raise_error
-    expect { ... }.to raise_error(ErrorClass)
-    expect { ... }.to raise_error("message")
-    expect { ... }.to raise_error(ErrorClass, "message")
+```ruby
+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')
+```ruby
+expect { ... }.to throw_symbol
+expect { ... }.to throw_symbol(:symbol)
+expect { ... }.to throw_symbol(:symbol, 'value')
+```
 
 ### Predicate matchers
 
-    actual.should be_xxx         # passes if actual.xxx?
-    actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+```ruby
+actual.should be_xxx         # passes if actual.xxx?
+actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+```
 
 See [RSpec::Matchers](../RSpec/Matchers) for more about predicate matchers.
 
 ### Ranges (Ruby >= 1.9 only)
 
-    (1..10).should cover(3)
+```ruby
+(1..10).should cover(3)
+```
 
 ### Collection membership
 
-    actual.should include(expected)
+```ruby
+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")
+```ruby
+[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")
+```
 
 ## Learn more
 

data/features/built_in_matchers/README.md

@@ -1,16 +1,33 @@
+# Built-in Matchers
+
+Here is a list of matchers that ship with rspec-expectations. Each matcher
+can be used with `should` or `should_not` e.g.
+
+    result.should eq(3)
+    list.should_not be_empty
+
 ## Object identity
 
-    actual.should equal(expected) # passes if actual.equal?(expected)
+    actual.should be(expected) # passes if actual.equal?(expected)
     
 ## Object equivalence
 
-    actual.should == expected   # passes if actual == expected
-    actual.should eql(expected) # passes if actual.eql?(expected)
+    actual.should eq(expected) # passes if actual == expected
 
 ## Optional APIs for identity/equivalence
 
-    actual.should eq(expected)  # passes if actual == expected
-    actual.should be(expected)  # passes if actual.equal?(expected)
+    actual.should == expected     # passes if actual == expected
+    actual.should eql(expected)   # passes if actual.eql?(expected)
+    actual.should equal(expected) # passes if actual.equal?(expected)
+
+    # NOTE: this can't work in Ruby 1.8, so we don't support it at all:
+    #   actual.should != expected
+    # The reason is that Ruby 1.8 parses it as:
+    #   !(actual.should.==(expected)),
+    # so by the time RSpec sees it it has no way to know that it's
+    # been negated. Use either of these instead:
+    #   actual.should_not eq(expected)
+    #   actual.should_not == expected
 
 ## Comparisons
 

data/lib/rspec/expectations/fail_with.rb

@@ -11,7 +11,7 @@ module RSpec
       # @param [Object] expected
       # @param [Object] actual
       #
-      # Adds a diff to the failure message when +expected+ and +actual+ are
+      # Adds a diff to the failure message when `expected` and `actual` are
       # both present.
       def fail_with(message, expected=nil, actual=nil)
         if !message
@@ -22,10 +22,10 @@ module RSpec
         if actual && expected
           if all_strings?(actual, expected)
             if any_multiline_strings?(actual, expected)
-              message << "\nDiff:" << self.differ.diff_as_string(actual, expected)
+              message << "\nDiff:" << differ.diff_as_string(actual, expected)
             end
           elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            message << "\nDiff:" << self.differ.diff_as_object(actual, expected)
+            message << "\nDiff:" << differ.diff_as_object(actual, expected)
           end
         end
 

data/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '2.8.0.rc1'
+      STRING = '2.8.0.rc2'
     end
   end
 end

data/lib/rspec/matchers/base_matcher.rb

@@ -1,5 +1,7 @@
 module RSpec
   module Matchers
+    # @api private
+    #
     # Used _internally_ as a base class for matchers that ship with
     # rspec-expectations.
     #
@@ -11,7 +13,7 @@ module RSpec
     module BaseMatcher
       include RSpec::Matchers::Pretty
 
-      attr_reader :actual, :expected
+      attr_reader :actual, :expected, :rescued_exception
 
       def initialize(expected=nil)
         @expected = expected
@@ -21,6 +23,15 @@ module RSpec
         @actual = actual
       end
 
+      def match_unless_raises(exception=Exception)
+        begin
+          yield
+          true
+        rescue exception => @rescued_exception
+          false
+        end
+      end
+
       def failure_message_for_should
         "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
       end
@@ -36,6 +47,10 @@ module RSpec
       def diffable?
         false
       end
+
+      def ==(other)
+        matches?(other)
+      end
     end
   end
 end

data/lib/rspec/matchers/dsl.rb

@@ -4,9 +4,10 @@ module RSpec
       # Defines a custom matcher.
       # @see RSpec::Matchers
       def define(name, &declarations)
+        matcher = RSpec::Matchers::Matcher.new(name, &declarations)
         define_method name do |*expected|
           $matcher_execution_context = self
-          RSpec::Matchers::Matcher.new name, *expected, &declarations
+          matcher.for_expected *expected
         end
       end
 

data/lib/rspec/matchers/matcher.rb

@@ -1,16 +1,20 @@
 module RSpec
   module Matchers
+    # Provides the context in which the block passed to RSpec::Matchers.define
+    # will be evaluated.
     class Matcher
       include RSpec::Matchers::Extensions::InstanceEvalWithArgs
       include RSpec::Matchers::Pretty
       include RSpec::Matchers
 
       attr_reader :expected, :actual, :rescued_exception
-      def initialize(name, *expected, &declarations)
-        @name     = name
-        @expected = expected
-        @actual   = nil
-        @diffable = false
+
+      # @api private
+      def initialize(name, &declarations)
+        @name         = name
+        @declarations = declarations
+        @actual       = nil
+        @diffable     = false
         @expected_exception, @rescued_exception = nil, nil
         @match_for_should_not_block = nil
 
@@ -19,12 +23,19 @@ module RSpec
           :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
           :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
         }
+      end
+
+      # @api private
+      def for_expected(*expected)
+        @expected = expected
         making_declared_methods_public do
-          instance_eval_with_args(*@expected, &declarations)
+          instance_eval_with_args(*@expected, &@declarations)
         end
+        self
       end
-      
-      #Used internally by +should+ and +should_not+.
+
+      # @api private
+      # Used internally by +should+ and +should_not+.
       def matches?(actual)
         @actual = actual
         if @expected_exception
@@ -43,65 +54,142 @@ module RSpec
         end
       end
 
-      # Used internally by +should_not+
-      def does_not_match?(actual)
-        @actual = actual
-        @match_for_should_not_block ?
-          instance_eval_with_args(actual, &@match_for_should_not_block) :
-          !matches?(actual)
-      end
-
-      def include(*args)
-        singleton_class.__send__(:include, *args)
-      end
-
-      def define_method(name, &block)
-        singleton_class.__send__(:define_method, name, &block)
-      end
-
-      # See RSpec::Matchers
+      # Stores the block that is used to determine whether this matcher passes
+      # or fails. The block should return a boolean value. When the matcher is
+      # passed to `should` and the block returns `true`, then the expectation
+      # passes. Similarly, when the matcher is passed to `should_not` and the
+      # block returns `false`, then the expectation passes.
+      #
+      # Use `match_for_should` when used in conjuntion with
+      # `match_for_should_not`.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :be_even do
+      #       match do |actual|
+      #         actual.even?
+      #       end
+      #     end
+      #
+      #     4.should be_even     # passes
+      #     3.should_not be_even # passes
+      #     3.should be_even     # fails
+      #     4.should_not be_even # fails
+      #
+      # @yield [Object] actual the actual value (or receiver of should)
       def match(&block)
         @match_block = block
       end
-      alias match_for_should match
 
-      # See RSpec::Matchers
+      alias_method :match_for_should, :match
+
+      # Use this to define the block for a negative expectation (`should_not`)
+      # when the positive and negative forms require different handling. This
+      # is rarely necessary, but can be helpful, for example, when specifying
+      # asynchronous processes that require different timeouts.
+      #
+      # @yield [Object] actual the actual value (or receiver of should)
       def match_for_should_not(&block)
         @match_for_should_not_block = block
       end
 
-      # See RSpec::Matchers
+      # Use this instead of `match` when the block will raise an exception
+      # rather than returning false to indicate a failure.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
+      #       match_unless_raises ValidationException do |validator|
+      #         validator.validate(candidate_address)
+      #       end
+      #     end
+      #
+      #     email_validator.should accept_as_valid("person@company.com")
       def match_unless_raises(exception=Exception, &block)
         @expected_exception = exception
         match(&block)
       end
 
-      # See RSpec::Matchers
+      # Customize the failure messsage to use when this matcher is invoked with
+      # `should`. Only use this when the message generated by default doesn't
+      # suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_strength do |expected|
+      #       match { ... }
+      #
+      #       failure_message_for_should do |actual|
+      #         "Expected strength of #{expected}, but had #{actual.strength}"
+      #       end
+      #     end
+      #
+      # @yield [Object] actual the actual object
       def failure_message_for_should(&block)
         cache_or_call_cached(:failure_message_for_should, &block)
       end
 
-      # See RSpec::Matchers
+      # Customize the failure messsage to use when this matcher is invoked with
+      # `should_not`. Only use this when the message generated by default
+      # doesn't suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_strength do |expected|
+      #       match { ... }
+      #
+      #       failure_message_for_should_not do |actual|
+      #         "Expected not to have strength of #{expected}, but did"
+      #       end
+      #     end
+      #
+      # @yield [Object] actual the actual object
+      # @yield [Object] actual the actual object
       def failure_message_for_should_not(&block)
         cache_or_call_cached(:failure_message_for_should_not, &block)
       end
 
-      # See RSpec::Matchers
+
+      # Customize the description to use for one-liners.  Only use this when
+      # the description generated by default doesn't suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :qualify_for do |expected|
+      #       match { ... }
+      #
+      #       description do
+      #         "qualify for #{expected}"
+      #       end
+      #     end
       def description(&block)
         cache_or_call_cached(:description, &block)
       end
 
-      #Used internally by objects returns by +should+ and +should_not+.
-      def diffable?
-        @diffable
-      end
-
-      # See RSpec::Matchers
+      # Tells the matcher to diff the actual and expected values in the failure
+      # message.
       def diffable
         @diffable = true
       end
       
-      # See RSpec::Matchers
+      # Convenience for defining methods on this matcher to create a fluent
+      # interface. The trick about fluent interfaces is that each method must
+      # return self in order to chain methods together. `chain` handles that
+      # for you.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_errors_on do |key|
+      #       chain :with do |message|
+      #         @message = message
+      #       end
+      #
+      #       match do |actual|
+      #         actual.errors[key] == @message
+      #       end
+      #     end
+      #
+      #     minor.should have_errors_on(:age).with("Not old enough to participate")
       def chain(method, &block)
         define_method method do |*args|
           block.call(*args)
@@ -109,8 +197,31 @@ module RSpec
         end
       end
       
+      # @api private
+      # Used internally by objects returns by +should+ and +should_not+.
+      def diffable?
+        @diffable
+      end
+
+      # @api private
+      # Used internally by +should_not+
+      def does_not_match?(actual)
+        @actual = actual
+        @match_for_should_not_block ?
+          instance_eval_with_args(actual, &@match_for_should_not_block) :
+          !matches?(actual)
+      end
+
     private
 
+      def include(*args)
+        singleton_class.__send__(:include, *args)
+      end
+
+      def define_method(name, &block)
+        singleton_class.__send__(:define_method, name, &block)
+      end
+
       def method_missing(method, *args, &block)
         if $matcher_execution_context.respond_to?(method)
           $matcher_execution_context.send method, *args, &block

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -0,0 +1,53 @@
+module RSpec::Matchers
+
+  describe BaseMatcher do
+    describe "#match_unless_raises" do
+      let(:matcher) do
+        Class.new do
+          include BaseMatcher
+        end.new
+      end
+
+      it "returns true if there are no errors" do
+        matcher.match_unless_raises {}.should be_true
+      end
+
+      it "returns false if there is an error" do
+        matcher.match_unless_raises { raise }.should be_false
+      end
+
+      it "returns false if the submitted error is raised" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }.should be_false
+      end
+
+      it "re-raises any error other than the one specified" do
+        expect do
+          matcher.match_unless_raises(ArgumentError){ raise "foo" }
+        end.to raise_error
+      end
+
+      it "stores the rescued exception for use in messages" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }
+        matcher.rescued_exception.should be_a(RuntimeError)
+        matcher.rescued_exception.message.should eq("foo")
+      end
+
+    end
+
+    describe "#==" do
+      it "responds the same way as matches?" do
+        matcher = Class.new do
+          include BaseMatcher
+          def matches?(actual)
+            actual == expected
+          end
+        end
+        matcher.new(3).matches?(3).should be_true
+        matcher.new(3).should eq(3)
+
+        matcher.new(3).matches?(4).should be_false
+        matcher.new(3).should_not eq(4)
+      end
+    end
+  end
+end

data/spec/rspec/matchers/dsl_spec.rb

@@ -3,23 +3,6 @@ require 'spec_helper'
 module RSpec
   module Matchers
     module DSL
-      describe "#define" do
-        it "creates a method that initializes a new matcher with the submitted name and expected arg" do
-          # FIXME - this expects new to be called, but we need something
-          # more robust - that expects new to be called with a specific
-          # block (lambda, proc, whatever)
-          mod = Module.new
-          mod.extend RSpec::Matchers::DSL
-          mod.define(:foo)
-    
-          obj = Object.new
-          obj.extend mod
-    
-          RSpec::Matchers::Matcher.should_receive(:new).with(:foo, 3) { stub('matcher').as_null_object }
-
-          obj.foo(3)
-        end
-      end
     end
   end
 end

data/spec/rspec/matchers/matcher_spec.rb

@@ -27,7 +27,7 @@ module RSpec
           RSpec::Matchers::Matcher.new(:be_a_greeting) do
             include MatcherHelperModule
             match { |actual| actual == greeting }
-          end
+          end.for_expected
         end
 
         it "has access to the module's methods" do
@@ -45,7 +45,7 @@ module RSpec
         it 'allows multiple modules to be included at once' do
           m = RSpec::Matchers::Matcher.new(:multiple_modules) do
             include Enumerable, Comparable
-          end
+          end.for_expected
           m.should be_a(Enumerable)
           m.should be_a(Comparable)
         end
@@ -53,11 +53,11 @@ module RSpec
 
       context "without overrides" do
         before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple|
+          @matcher = RSpec::Matchers::Matcher.new(:be_a_multiple_of) do |multiple|
             match do |actual|
               actual % multiple == 0
             end
-          end
+          end.for_expected(3)
         end
 
         it "provides a default description" do
@@ -77,7 +77,7 @@ module RSpec
 
       context "with separate match logic for should and should not" do
         let(:matcher) do
-          RSpec::Matchers::Matcher.new(:to_be_composed_of, 7, 11) do |a, b|
+          RSpec::Matchers::Matcher.new(:to_be_composed_of) do |a, b|
             match_for_should do |actual|
               actual == a * b
             end
@@ -85,7 +85,7 @@ module RSpec
             match_for_should_not do |actual|
               actual == a + b
             end
-          end
+          end.for_expected(7, 11)
         end
 
         it "invokes the match_for_should block for #matches?" do
@@ -105,9 +105,9 @@ module RSpec
       end
 
       it "allows helper methods to be defined with #define_method to have access to matcher parameters" do
-        matcher = RSpec::Matchers::Matcher.new(:name, 3, 4) do |a, b|
+        matcher = RSpec::Matchers::Matcher.new(:name) do |a, b|
           define_method(:sum) { a + b }
-        end
+        end.for_expected(3,4)
 
         matcher.sum.should == 7
       end
@@ -118,19 +118,19 @@ module RSpec
       end
 
       it "is diffable when told to be" do
-        matcher = RSpec::Matchers::Matcher.new(:name) { diffable }
+        matcher = RSpec::Matchers::Matcher.new(:name) { diffable }.for_expected
         matcher.should be_diffable
       end
 
       it "provides expected" do
-        matcher = RSpec::Matchers::Matcher.new(:name, 'expected string') {}
+        matcher = RSpec::Matchers::Matcher.new(:name) {}.for_expected('expected string')
         matcher.expected.should == ['expected string']
       end
 
       it "provides actual" do
-        matcher = RSpec::Matchers::Matcher.new(:name, 'expected string') do
+        matcher = RSpec::Matchers::Matcher.new(:name) do
           match {|actual|}
-        end
+        end.for_expected('expected string')
 
         matcher.matches?('actual string')
 
@@ -139,27 +139,27 @@ module RSpec
 
       context "wrapping another expectation (should == ...)" do
         it "returns true if the wrapped expectation passes" do
-          matcher = RSpec::Matchers::Matcher.new(:name, 'value') do |expected|
+          matcher = RSpec::Matchers::Matcher.new(:name) do |expected|
             match do |actual|
               actual.should == expected
             end
-          end
+          end.for_expected('value')
           matcher.matches?('value').should be_true
         end
 
         it "returns false if the wrapped expectation fails" do
-          matcher = RSpec::Matchers::Matcher.new(:name, 'value') do |expected|
+          matcher = RSpec::Matchers::Matcher.new(:name) do |expected|
             match do |actual|
               actual.should == expected
             end
-          end
+          end.for_expected('value')
           matcher.matches?('other value').should be_false
         end
       end
 
       context "with overrides" do
         before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:be_boolean, true) do |boolean|
+          @matcher = RSpec::Matchers::Matcher.new(:be_boolean) do |boolean|
             match do |actual|
               actual
             end
@@ -172,7 +172,7 @@ module RSpec
             failure_message_for_should_not do |actual|
               "expected #{actual} not to be the boolean #{boolean}"
             end
-          end
+          end.for_expected(true)
         end
 
         it "does not hide result of match block when true" do
@@ -204,16 +204,16 @@ module RSpec
             match do |actual|
               actual == 5
             end
-          end
+          end.for_expected
           matcher.matches?(5).should be_true
         end
 
         it "exposes arg submitted through #new to matcher block" do
-          matcher = RSpec::Matchers::Matcher.new(:ignore, 4) do |expected|
+          matcher = RSpec::Matchers::Matcher.new(:ignore) do |expected|
             match do |actual|
               actual > expected
             end
-          end
+          end.for_expected(4)
           matcher.matches?(5).should be_true
         end
       end
@@ -224,7 +224,7 @@ module RSpec
             match do |actual|
               actual == 5
             end
-          end
+          end.for_expected
         end
 
         it "matches" do
@@ -238,11 +238,11 @@ module RSpec
 
       context "with 1 arg" do
         before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:matcher_name, 1) do |expected|
+          @matcher = RSpec::Matchers::Matcher.new(:matcher_name) do |expected|
             match do |actual|
               actual == 5 && expected == 1
             end
-          end
+          end.for_expected(1)
         end
 
         it "matches" do
@@ -256,11 +256,11 @@ module RSpec
 
       context "with multiple args" do
         before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:matcher_name, 1, 2, 3, 4) do |a,b,c,d|
+          @matcher = RSpec::Matchers::Matcher.new(:matcher_name) do |a,b,c,d|
             match do |sum|
               a + b + c + d == sum
             end
-          end
+          end.for_expected(1,2,3,4)
         end
 
         it "matches" do
@@ -273,7 +273,7 @@ module RSpec
       end
 
       it "supports helper methods" do
-        matcher = RSpec::Matchers::Matcher.new(:be_similar_to, [1,2,3]) do |sample|
+        matcher = RSpec::Matchers::Matcher.new(:be_similar_to) do |sample|
           match do |actual|
             similar?(sample, actual)
           end
@@ -281,7 +281,7 @@ module RSpec
           def similar?(a, b)
             a.sort == b.sort
           end
-        end
+        end.for_expected([1,2,3])
 
         matcher.matches?([2,3,1]).should be_true
       end
@@ -291,23 +291,23 @@ module RSpec
           def second_word
             self
           end
-        end
+        end.for_expected
 
         matcher.second_word.should == matcher
       end
 
       it "treats method missing normally for undeclared methods" do
-        matcher = RSpec::Matchers::Matcher.new(:ignore) { }
+        matcher = RSpec::Matchers::Matcher.new(:ignore) { }.for_expected
         expect { matcher.non_existent_method }.to raise_error(NoMethodError)
       end
 
       it "has access to other matchers" do
-        matcher = RSpec::Matchers::Matcher.new(:ignore, 3) do |expected|
+        matcher = RSpec::Matchers::Matcher.new(:ignore) do |expected|
           match do |actual|
             extend RSpec::Matchers
             actual.should eql(5 + expected)
           end
-        end
+        end.for_expected(3)
 
         matcher.matches?(8).should be_true
       end
@@ -323,12 +323,12 @@ module RSpec
           end
           let(:matcher) do
             m = mod
-            RSpec::Matchers::Matcher.new :equal, 4 do |expected|
+            RSpec::Matchers::Matcher.new :equal do |expected|
               extend m
               match_unless_raises UnexpectedError do
                 assert_equal expected, actual
               end
-            end
+            end.for_expected(4)
           end
 
           context "with passing assertion" do
@@ -352,11 +352,11 @@ module RSpec
 
         context "with an unexpected error" do
           let(:matcher) do
-            RSpec::Matchers::Matcher.new :foo, :bar do |expected|
+            RSpec::Matchers::Matcher.new :foo do |expected|
               match_unless_raises SyntaxError do |actual|
                 raise "unexpected exception"
               end
-            end
+            end.for_expected(:bar)
           end
 
           it "raises the error" do
@@ -374,15 +374,15 @@ module RSpec
             @expected_value = expected_value
           end
           match { |actual| actual == @expected_value }
-        end
+        end.for_expected
 
         matcher.expecting('value').matches?('value').should be_true
         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" } }
+        m1 = RSpec::Matchers::Matcher.new(:m1) { chain(:foo) { raise "foo in m1" } }.for_expected
+        m2 = RSpec::Matchers::Matcher.new(:m2) { chain(:foo) { raise "foo in m2" } }.for_expected
 
         expect { m1.foo }.to raise_error("foo in m1")
         expect { m2.foo }.to raise_error("foo in m2")

metadata

@@ -1,24 +1,24 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-expectations
 version: !ruby/object:Gem::Version 
-  hash: 15424215
+  hash: 15424209
   prerelease: 6
   segments: 
   - 2
   - 8
   - 0
   - rc
-  - 1
-  version: 2.8.0.rc1
+  - 2
+  version: 2.8.0.rc2
 platform: ruby
 authors: 
+- Steven Baker
 - David Chelimsky
-- Chad Humphries
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-11-06 00:00:00 Z
+date: 2011-12-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -32,18 +32,19 @@ dependencies:
         - 1
         - 2
         version: 1.1.2
-  requirement: *id001
-  type: :runtime
   prerelease: false
+  requirement: *id001
   name: diff-lcs
+  type: :runtime
 description: rspec expectations (should[_not] and matchers)
-email: dchelimsky@gmail.com;chad.humphries@gmail.com
+email: rspec-users@rubyforge.org
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
 - README.md
+- License.txt
 files: 
 - lib/rspec-expectations.rb
 - lib/rspec/expectations.rb
@@ -89,6 +90,7 @@ files:
 - lib/rspec/matchers/respond_to.rb
 - lib/rspec/matchers/satisfy.rb
 - lib/rspec/matchers/throw_symbol.rb
+- License.txt
 - README.md
 - features/README.markdown
 - features/Upgrade.md
@@ -124,6 +126,7 @@ files:
 - spec/rspec/expectations/extensions/kernel_spec.rb
 - spec/rspec/expectations/fail_with_spec.rb
 - spec/rspec/expectations/handler_spec.rb
+- spec/rspec/matchers/base_matcher_spec.rb
 - spec/rspec/matchers/be_close_spec.rb
 - spec/rspec/matchers/be_instance_of_spec.rb
 - spec/rspec/matchers/be_kind_of_spec.rb
@@ -156,8 +159,8 @@ files:
 - spec/support/matchers.rb
 - spec/support/ruby_version.rb
 homepage: http://github.com/rspec/rspec-expectations
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -189,7 +192,7 @@ rubyforge_project: rspec
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: rspec-expectations-2.8.0.rc1
+summary: rspec-expectations-2.8.0.rc2
 test_files: 
 - features/README.markdown
 - features/Upgrade.md
@@ -225,6 +228,7 @@ test_files:
 - spec/rspec/expectations/extensions/kernel_spec.rb
 - spec/rspec/expectations/fail_with_spec.rb
 - spec/rspec/expectations/handler_spec.rb
+- spec/rspec/matchers/base_matcher_spec.rb
 - spec/rspec/matchers/be_close_spec.rb
 - spec/rspec/matchers/be_instance_of_spec.rb
 - spec/rspec/matchers/be_kind_of_spec.rb
@@ -256,3 +260,4 @@ test_files:
 - spec/support/classes.rb
 - spec/support/matchers.rb
 - spec/support/ruby_version.rb
+has_rdoc: