rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/method_missing.rb

@@ -4,8 +4,8 @@ module RSpec
     private
 
     def method_missing(method, *args, &block)
-      return Matchers::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
-      return Matchers::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
+      return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
       super
     end
   end

data/lib/rspec/matchers/operator_matcher.rb

@@ -34,7 +34,7 @@ module RSpec
           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."
+              "Use `#{opposite_should} #{operator} expected` instead."
           end
         end
       end
@@ -50,36 +50,35 @@ module RSpec
       def description
         "#{@operator} #{@expected.inspect}"
       end
-      
-    private
-      
+
+      private
+
       def eval_match(actual, operator, expected)
         ::RSpec::Matchers.last_matcher = self
         @operator, @expected = operator, expected
         __delegate_operator(actual, operator, expected)
       end
-
     end
 
-    class PositiveOperatorMatcher < OperatorMatcher
-      def __delegate_operator(actual, operator, expected)
-        if actual.__send__(operator, expected)
-          true
-        elsif ['==','===', '=~'].include?(operator)
-          fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})") 
-        else
-          fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+    module BuiltIn
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          elsif ['==','===', '=~'].include?(operator)
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})") 
+          else
+            fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          end
         end
       end
 
-    end
-
-    class NegativeOperatorMatcher < OperatorMatcher
-      def __delegate_operator(actual, operator, expected)
-        return false unless actual.__send__(operator, expected)
-        return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+          return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
       end
-
     end
   end
 end

data/spec/rspec/expectations/handler_spec.rb

@@ -159,7 +159,7 @@ module RSpec
             :diffable? => true,
             :failure_message_for_should_not => "message",
             :matches? => true,
-            :expected => [1],
+            :expected => 1,
             :actual   => 2
           )
           actual = Object.new

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -1,5 +1,4 @@
-module RSpec::Matchers
-
+module RSpec::Matchers::BuiltIn
   describe BaseMatcher do
     describe "#match_unless_raises" do
       let(:matcher) do

data/spec/rspec/matchers/change_spec.rb

@@ -171,7 +171,7 @@ describe "should change { block }" do
   it "warns if passed a block using do/end instead of {}" do
     expect do
       expect {}.to change do; end
-    end.to raise_error(RSpec::Matchers::MatcherError, /block passed to should or should_not/)
+    end.to raise_error(SyntaxError, /block passed to should or should_not/)
   end
   
   it "provides a #description" do
@@ -198,7 +198,7 @@ describe "should_not change { block }" do
   it "warns if passed a block using do/end instead of {}" do
     expect do
       expect {}.to_not change do; end
-    end.to raise_error(RSpec::Matchers::MatcherError, /block passed to should or should_not/)
+    end.to raise_error(SyntaxError, /block passed to should or should_not/)
   end
 end
 
@@ -509,7 +509,7 @@ describe "should change{ block }.from(old).to(new)" do
   end
 end
 
-describe RSpec::Matchers::Change do
+describe RSpec::Matchers::BuiltIn::Change do
   it "works when the receiver has implemented #send" do
     @instance = SomethingExpected.new
     @instance.some_value = "string"

data/spec/rspec/matchers/cover_spec.rb

@@ -1,65 +1,65 @@
 require 'spec_helper'
 
-describe "should cover(expected)", :if => RSpec::Matchers.respond_to?(:cover) do
-  context "for a range target" do
-    it "passes if target covers expected" do
-      (1..10).should cover(5)
-    end
+if (1..2).respond_to?(:cover?)
+  describe "should cover(expected)" do
+    context "for a range target" do
+      it "passes if target covers expected" do
+        (1..10).should cover(5)
+      end
 
-    it "fails if target does not cover expected" do
-      lambda {
-        (1..10).should cover(11)
-      }.should fail_with("expected 1..10 to cover 11")
+      it "fails if target does not cover expected" do
+        lambda {
+          (1..10).should cover(11)
+        }.should fail_with("expected 1..10 to cover 11")
+      end
     end
   end
-end
 
-describe "should cover(with, multiple, args)", :if => RSpec::Matchers.respond_to?(:cover) do
-  context "for a range target" do
-    it "passes if target covers all items" do
-      (1..10).should cover(4, 6)
-    end
+  describe "should cover(with, multiple, args)" do
+    context "for a range target" do
+      it "passes if target covers all items" do
+        (1..10).should cover(4, 6)
+      end
 
-    it "fails if target does not cover any one of the items" do
-      lambda {
-        (1..10).should cover(4, 6, 11)
-      }.should fail_with("expected 1..10 to cover 4, 6, and 11")
+      it "fails if target does not cover any one of the items" do
+        lambda {
+          (1..10).should cover(4, 6, 11)
+        }.should fail_with("expected 1..10 to cover 4, 6, and 11")
+      end
     end
   end
-end
 
-describe "should_not cover(expected)", :if => RSpec::Matchers.respond_to?(:cover) do
-  context "for a range target" do
-    it "passes if target does not cover expected" do
-      (1..10).should_not cover(11)
-    end
+  describe "should_not cover(expected)" do
+    context "for a range target" do
+      it "passes if target does not cover expected" do
+        (1..10).should_not cover(11)
+      end
 
-    it "fails if target covers expected" do
-      lambda {
-        (1..10).should_not cover(5)
-      }.should fail_with("expected 1..10 not to cover 5")
+      it "fails if target covers expected" do
+        lambda {
+          (1..10).should_not cover(5)
+        }.should fail_with("expected 1..10 not to cover 5")
+      end
     end
   end
-end
 
-describe "should_not cover(with, multiple, args)", :if => RSpec::Matchers.respond_to?(:cover) do
-  context "for a range target" do
-    it "passes if the target does not cover any of the expected" do
-      (1..10).should_not include(11, 12, 13)
-    end
+  describe "should_not cover(with, multiple, args)" do
+    context "for a range target" do
+      it "passes if the target does not cover any of the expected" do
+        (1..10).should_not cover(11, 12, 13)
+      end
 
-    it "fails if the target covers all of the expected" do
-      expect {
-        (1..10).should_not include(4, 6)
-      }.to fail_with("expected 1..10 not to include 4 and 6")
-    end
+      it "fails if the target covers all of the expected" do
+        expect {
+          (1..10).should_not cover(4, 6)
+        }.to fail_with("expected 1..10 not to cover 4 and 6")
+      end
 
-    it "fails if the target covers some (but not all) of the expected" do
-      expect {
-        (1..10).should_not include(5, 11)
-      }.to fail_with("expected 1..10 not to include 5 and 11")
+      it "fails if the target covers some (but not all) of the expected" do
+        expect {
+          (1..10).should_not cover(5, 11)
+        }.to fail_with("expected 1..10 not to cover 5 and 11")
+      end
     end
   end
 end
-
-

data/spec/rspec/matchers/dsl_spec.rb

@@ -1,8 +1,41 @@
 require 'spec_helper'
 
-module RSpec
-  module Matchers
-    module DSL
+describe "a matcher defined using the matcher DSL" do
+  def question?
+    :answer
+  end
+
+  it "has access to methods available in the scope of the example" do
+    RSpec::Matchers::define(:ignore) {}
+    ignore.question?.should eq(:answer)
+  end
+
+  it "raises when method is missing from local scope as well as matcher" do
+    RSpec::Matchers::define(:ignore) {}
+    expect { ignore.i_dont_exist }.to raise_error(NameError)
+  end
+
+  it "clears user instance variables between invocations" do
+    RSpec::Matchers::define(:be_just_like) do |expected|
+      match do |actual|
+        @foo ||= expected
+        @foo == actual
+      end
+    end
+
+    3.should be_just_like(3)
+    4.should be_just_like(4)
+  end
+
+  describe "#respond_to?" do
+    it "returns true for methods in example scope" do
+      RSpec::Matchers::define(:ignore) {}
+      ignore.should respond_to(:question?)
+    end
+
+    it "returns false for methods not defined in matcher or example scope" do
+      RSpec::Matchers::define(:ignore) {}
+      ignore.should_not respond_to(:i_dont_exist)
     end
   end
 end

data/spec/rspec/matchers/have_spec.rb

@@ -390,7 +390,7 @@ EOF
     end
   end
 
-  describe RSpec::Matchers::Have, "for a collection owner that implements #send" do
+  describe RSpec::Matchers::BuiltIn::Have, "for a collection owner that implements #send" do
     before(:each) do
       @collection = Object.new
       def @collection.floozles; [1,2] end
@@ -415,7 +415,7 @@ EOF
     end
   end
 
-  describe RSpec::Matchers::Have do
+  describe RSpec::Matchers::BuiltIn::Have do
     it "has method_missing as private" do
       described_class.private_instance_methods.should include_method(:method_missing)
     end

data/spec/rspec/matchers/include_spec.rb

@@ -133,7 +133,7 @@ describe "#include matcher" do
       it "fails if the target includes all of the expected" do
         expect {
           "abc".should_not include("c", "a")
-        }.to fail_with(%q{expected "abc" not to include "c" and "a"})
+        }.to fail_with('expected "abc" not to include "c" and "a"')
       end
 
       it "fails if the target includes some (but not all) of the expected" do

data/spec/rspec/matchers/matcher_spec.rb

@@ -19,402 +19,416 @@ module MatcherHelperModule
   end
 end
 
-module RSpec
-  module Matchers
-    describe Matcher do
-      context "with an included module" do
-        let(:matcher) do
-          RSpec::Matchers::Matcher.new(:be_a_greeting) do
-            include MatcherHelperModule
-            match { |actual| actual == greeting }
-          end.for_expected
-        end
-
-        it "has access to the module's methods" do
-          matcher.matches?("Hello, World")
-        end
-
-        it "runs the module's included hook" do
-          matcher.should respond_to(:included_method)
-        end
-
-        it "does not run the module's extended hook" do
-          matcher.should_not respond_to(:extended_method)
-        end
-
-        it 'allows multiple modules to be included at once' do
-          m = RSpec::Matchers::Matcher.new(:multiple_modules) do
-            include Enumerable, Comparable
-          end.for_expected
-          m.should be_a(Enumerable)
-          m.should be_a(Comparable)
+module RSpec::Matchers::DSL
+  describe Matcher do
+    it "can be stored aside and used later" do
+      # Supports using rspec-expectation matchers as argument matchers in
+      # rspec-mocks.
+      RSpec::Matchers.define :example_matcher do |expected|
+        match do |actual|
+          actual == expected
         end
       end
 
-      context "without overrides" do
-        before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:be_a_multiple_of) do |multiple|
-            match do |actual|
-              actual % multiple == 0
-            end
-          end.for_expected(3)
-        end
+      m1 = example_matcher(1)
+      m2 = example_matcher(2)
 
-        it "provides a default description" do
-          @matcher.description.should == "be a multiple of 3"
-        end
-
-        it "provides a default failure message for #should" do
-          @matcher.matches?(8)
-          @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3"
-        end
+      m1.matches?(1).should be_true
+      m2.matches?(2).should be_true
+    end
 
-        it "provides a default failure message for #should_not" do
-          @matcher.matches?(9)
-          @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3"
-        end
+    context "with an included module" do
+      let(:matcher) do
+        RSpec::Matchers::DSL::Matcher.new(:be_a_greeting) do
+          include MatcherHelperModule
+          match { |actual| actual == greeting }
+        end.for_expected
       end
 
-      context "with separate match logic for should and should not" do
-        let(:matcher) do
-          RSpec::Matchers::Matcher.new(:to_be_composed_of) do |a, b|
-            match_for_should do |actual|
-              actual == a * b
-            end
-
-            match_for_should_not do |actual|
-              actual == a + b
-            end
-          end.for_expected(7, 11)
-        end
-
-        it "invokes the match_for_should block for #matches?" do
-          matcher.matches?(77).should be_true
-          matcher.matches?(18).should be_false
-        end
-
-        it "invokes the match_for_should_not block for #does_not_match?" do
-          matcher.does_not_match?(77).should be_false
-          matcher.does_not_match?(18).should be_true
-        end
+      it "has access to the module's methods" do
+        matcher.matches?("Hello, World")
+      end
 
-        it "provides a default failure message for #should_not" do
-          matcher.does_not_match?(77)
-          matcher.failure_message_for_should_not.should == "expected 77 not to to be composed of 7 and 11"
-        end
+      it "runs the module's included hook" do
+        matcher.should respond_to(:included_method)
       end
 
-      it "allows helper methods to be defined with #define_method to have access to matcher parameters" do
-        matcher = RSpec::Matchers::Matcher.new(:name) do |a, b|
-          define_method(:sum) { a + b }
-        end.for_expected(3,4)
+      it "does not run the module's extended hook" do
+        matcher.should_not respond_to(:extended_method)
+      end
 
-        matcher.sum.should == 7
+      it 'allows multiple modules to be included at once' do
+        m = RSpec::Matchers::DSL::Matcher.new(:multiple_modules) do
+          include Enumerable, Comparable
+        end.for_expected
+        m.should be_a(Enumerable)
+        m.should be_a(Comparable)
       end
+    end
 
-      it "is not diffable by default" do
-        matcher = RSpec::Matchers::Matcher.new(:name) {}
-        matcher.should_not be_diffable
+    context "without overrides" do
+      before(:each) do
+        @matcher = RSpec::Matchers::DSL::Matcher.new(:be_a_multiple_of) do |multiple|
+          match do |actual|
+            actual % multiple == 0
+          end
+        end.for_expected(3)
       end
 
-      it "is diffable when told to be" do
-        matcher = RSpec::Matchers::Matcher.new(:name) { diffable }.for_expected
-        matcher.should be_diffable
+      it "provides a default description" do
+        @matcher.description.should == "be a multiple of 3"
       end
 
-      it "provides expected" do
-        matcher = RSpec::Matchers::Matcher.new(:name) {}.for_expected('expected string')
-        matcher.expected.should == ['expected string']
+      it "provides a default failure message for #should" do
+        @matcher.matches?(8)
+        @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3"
       end
 
-      it "provides actual" do
-        matcher = RSpec::Matchers::Matcher.new(:name) do
-          match {|actual|}
-        end.for_expected('expected string')
+      it "provides a default failure message for #should_not" do
+        @matcher.matches?(9)
+        @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3"
+      end
+    end
 
-        matcher.matches?('actual string')
+    context "with separate match logic for should and should not" do
+      let(:matcher) do
+        RSpec::Matchers::DSL::Matcher.new(:to_be_composed_of) do |a, b|
+          match_for_should do |actual|
+            actual == a * b
+          end
 
-        matcher.actual.should == 'actual string'
+          match_for_should_not do |actual|
+            actual == a + b
+          end
+        end.for_expected(7, 11)
       end
 
-      context "wrapping another expectation (should == ...)" do
-        it "returns true if the wrapped expectation passes" do
-          matcher = RSpec::Matchers::Matcher.new(:name) do |expected|
-            match do |actual|
-              actual.should == expected
-            end
-          end.for_expected('value')
-          matcher.matches?('value').should be_true
-        end
+      it "invokes the match_for_should block for #matches?" do
+        matcher.matches?(77).should be_true
+        matcher.matches?(18).should be_false
+      end
 
-        it "returns false if the wrapped expectation fails" do
-          matcher = RSpec::Matchers::Matcher.new(:name) do |expected|
-            match do |actual|
-              actual.should == expected
-            end
-          end.for_expected('value')
-          matcher.matches?('other value').should be_false
-        end
+      it "invokes the match_for_should_not block for #does_not_match?" do
+        matcher.does_not_match?(77).should be_false
+        matcher.does_not_match?(18).should be_true
       end
 
-      context "with overrides" do
-        before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:be_boolean) do |boolean|
-            match do |actual|
-              actual
-            end
-            description do
-              "be the boolean #{boolean}"
-            end
-            failure_message_for_should do |actual|
-              "expected #{actual} to be the boolean #{boolean}"
-            end
-            failure_message_for_should_not do |actual|
-              "expected #{actual} not to be the boolean #{boolean}"
-            end
-          end.for_expected(true)
-        end
+      it "provides a default failure message for #should_not" do
+        matcher.does_not_match?(77)
+        matcher.failure_message_for_should_not.should == "expected 77 not to to be composed of 7 and 11"
+      end
+    end
 
-        it "does not hide result of match block when true" do
-          @matcher.matches?(true).should be_true
-        end
+    it "allows helper methods to be defined with #define_method to have access to matcher parameters" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) do |a, b|
+        define_method(:sum) { a + b }
+      end.for_expected(3,4)
 
-        it "does not hide result of match block when false" do
-          @matcher.matches?(false).should be_false
-        end
+      matcher.sum.should == 7
+    end
 
-        it "overrides the description" do
-          @matcher.description.should == "be the boolean true"
-        end
+    it "is not diffable by default" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) {}
+      matcher.should_not be_diffable
+    end
 
-        it "overrides the failure message for #should" do
-          @matcher.matches?(false)
-          @matcher.failure_message_for_should.should == "expected false to be the boolean true"
-        end
+    it "is diffable when told to be" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) { diffable }.for_expected
+      matcher.should be_diffable
+    end
 
-        it "overrides the failure message for #should_not" do
-          @matcher.matches?(true)
-          @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true"
-        end
-      end
+    it "provides expected" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) {}.for_expected('expected string')
+      matcher.expected.should == ['expected string']
+    end
 
-      context "#new" do
-        it "passes matches? arg to match block" do
-          matcher = RSpec::Matchers::Matcher.new(:ignore) do
-            match do |actual|
-              actual == 5
-            end
-          end.for_expected
-          matcher.matches?(5).should be_true
-        end
+    it "provides actual" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) do
+        match {|actual|}
+      end.for_expected('expected string')
 
-        it "exposes arg submitted through #new to matcher block" do
-          matcher = RSpec::Matchers::Matcher.new(:ignore) do |expected|
-            match do |actual|
-              actual > expected
-            end
-          end.for_expected(4)
-          matcher.matches?(5).should be_true
-        end
-      end
+      matcher.matches?('actual string')
 
-      context "with no args" do
-        before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:matcher_name) do
-            match do |actual|
-              actual == 5
-            end
-          end.for_expected
-        end
+      matcher.actual.should == 'actual string'
+    end
 
-        it "matches" do
-          @matcher.matches?(5).should be_true
-        end
+    context "wrapping another expectation (should == ...)" do
+      it "returns true if the wrapped expectation passes" do
+        matcher = RSpec::Matchers::DSL::Matcher.new(:name) do |expected|
+          match do |actual|
+            actual.should == expected
+          end
+        end.for_expected('value')
+        matcher.matches?('value').should be_true
+      end
 
-        it "describes" do
-          @matcher.description.should == "matcher name"
-        end
+      it "returns false if the wrapped expectation fails" do
+        matcher = RSpec::Matchers::DSL::Matcher.new(:name) do |expected|
+          match do |actual|
+            actual.should == expected
+          end
+        end.for_expected('value')
+        matcher.matches?('other value').should be_false
       end
+    end
 
-      context "with 1 arg" do
-        before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:matcher_name) do |expected|
-            match do |actual|
-              actual == 5 && expected == 1
-            end
-          end.for_expected(1)
-        end
+    context "with overrides" do
+      before(:each) do
+        @matcher = RSpec::Matchers::DSL::Matcher.new(:be_boolean) do |boolean|
+          match do |actual|
+            actual
+          end
+          description do
+            "be the boolean #{boolean}"
+          end
+          failure_message_for_should do |actual|
+            "expected #{actual} to be the boolean #{boolean}"
+          end
+          failure_message_for_should_not do |actual|
+            "expected #{actual} not to be the boolean #{boolean}"
+          end
+        end.for_expected(true)
+      end
 
-        it "matches" do
-          @matcher.matches?(5).should be_true
-        end
+      it "does not hide result of match block when true" do
+        @matcher.matches?(true).should be_true
+      end
 
-        it "describes" do
-          @matcher.description.should == "matcher name 1"
-        end
+      it "does not hide result of match block when false" do
+        @matcher.matches?(false).should be_false
       end
 
-      context "with multiple args" do
-        before(:each) do
-          @matcher = RSpec::Matchers::Matcher.new(:matcher_name) do |a,b,c,d|
-            match do |sum|
-              a + b + c + d == sum
-            end
-          end.for_expected(1,2,3,4)
-        end
+      it "overrides the description" do
+        @matcher.description.should == "be the boolean true"
+      end
 
-        it "matches" do
-          @matcher.matches?(10).should be_true
-        end
+      it "overrides the failure message for #should" do
+        @matcher.matches?(false)
+        @matcher.failure_message_for_should.should == "expected false to be the boolean true"
+      end
 
-        it "describes" do
-          @matcher.description.should == "matcher name 1, 2, 3, and 4"
-        end
+      it "overrides the failure message for #should_not" do
+        @matcher.matches?(true)
+        @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true"
       end
+    end
 
-      it "supports helper methods" do
-        matcher = RSpec::Matchers::Matcher.new(:be_similar_to) do |sample|
+    context "#new" do
+      it "passes matches? arg to match block" do
+        matcher = RSpec::Matchers::DSL::Matcher.new(:ignore) do
           match do |actual|
-            similar?(sample, actual)
+            actual == 5
           end
+        end.for_expected
+        matcher.matches?(5).should be_true
+      end
 
-          def similar?(a, b)
-            a.sort == b.sort
+      it "exposes arg submitted through #new to matcher block" do
+        matcher = RSpec::Matchers::DSL::Matcher.new(:ignore) do |expected|
+          match do |actual|
+            actual > expected
           end
-        end.for_expected([1,2,3])
-
-        matcher.matches?([2,3,1]).should be_true
+        end.for_expected(4)
+        matcher.matches?(5).should be_true
       end
+    end
 
-      it "supports fluent interface" do
-        matcher = RSpec::Matchers::Matcher.new(:first_word) do
-          def second_word
-            self
+    context "with no args" do
+      before(:each) do
+        @matcher = RSpec::Matchers::DSL::Matcher.new(:matcher_name) do
+          match do |actual|
+            actual == 5
           end
         end.for_expected
+      end
 
-        matcher.second_word.should == matcher
+      it "matches" do
+        @matcher.matches?(5).should be_true
       end
 
-      it "treats method missing normally for undeclared methods" do
-        matcher = RSpec::Matchers::Matcher.new(:ignore) { }.for_expected
-        expect { matcher.non_existent_method }.to raise_error(NoMethodError)
+      it "describes" do
+        @matcher.description.should == "matcher name"
       end
+    end
 
-      it "has access to other matchers" do
-        matcher = RSpec::Matchers::Matcher.new(:ignore) do |expected|
+    context "with 1 arg" do
+      before(:each) do
+        @matcher = RSpec::Matchers::DSL::Matcher.new(:matcher_name) do |expected|
           match do |actual|
-            extend RSpec::Matchers
-            actual.should eql(5 + expected)
+            actual == 5 && expected == 1
           end
-        end.for_expected(3)
+        end.for_expected(1)
+      end
 
-        matcher.matches?(8).should be_true
+      it "matches" do
+        @matcher.matches?(5).should be_true
       end
 
-      describe "#match_unless_raises" do
-        context "with an assertion" do
-          let(:mod) do
-            Module.new do
-              def assert_equal(a,b)
-                a == b ? nil : (raise UnexpectedError.new("#{b} does not equal #{a}"))
-              end
-            end
-          end
-          let(:matcher) do
-            m = mod
-            RSpec::Matchers::Matcher.new :equal do |expected|
-              extend m
-              match_unless_raises UnexpectedError do
-                assert_equal expected, actual
-              end
-            end.for_expected(4)
+      it "describes" do
+        @matcher.description.should == "matcher name 1"
+      end
+    end
+
+    context "with multiple args" do
+      before(:each) do
+        @matcher = RSpec::Matchers::DSL::Matcher.new(:matcher_name) do |a,b,c,d|
+          match do |sum|
+            a + b + c + d == sum
           end
+        end.for_expected(1,2,3,4)
+      end
+
+      it "matches" do
+        @matcher.matches?(10).should be_true
+      end
+
+      it "describes" do
+        @matcher.description.should == "matcher name 1, 2, 3, and 4"
+      end
+    end
+
+    it "supports helper methods" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:be_similar_to) do |sample|
+        match do |actual|
+          similar?(sample, actual)
+        end
+
+        def similar?(a, b)
+          a.sort == b.sort
+        end
+      end.for_expected([1,2,3])
+
+      matcher.matches?([2,3,1]).should be_true
+    end
+
+    it "supports fluent interface" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:first_word) do
+        def second_word
+          self
+        end
+      end.for_expected
 
-          context "with passing assertion" do
-            it "passes" do
-              matcher.matches?(4).should be_true
+      matcher.second_word.should == matcher
+    end
+
+    it "treats method missing normally for undeclared methods" do
+      matcher = RSpec::Matchers::DSL::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::DSL::Matcher.new(:ignore) do |expected|
+        match do |actual|
+          extend RSpec::Matchers
+          actual.should eql(5 + expected)
+        end
+      end.for_expected(3)
+
+      matcher.matches?(8).should be_true
+    end
+
+    describe "#match_unless_raises" do
+      context "with an assertion" do
+        let(:mod) do
+          Module.new do
+            def assert_equal(a,b)
+              a == b ? nil : (raise UnexpectedError.new("#{b} does not equal #{a}"))
             end
           end
-
-          context "with failing assertion" do
-            it "fails" do
-              matcher.matches?(5).should be_false
+        end
+        let(:matcher) do
+          m = mod
+          RSpec::Matchers::DSL::Matcher.new :equal do |expected|
+            extend m
+            match_unless_raises UnexpectedError do
+              assert_equal expected, actual
             end
+          end.for_expected(4)
+        end
 
-            it "provides the raised exception" do
-              matcher.matches?(5)
-              matcher.rescued_exception.message.
-                should eq("5 does not equal 4")
-            end
+        context "with passing assertion" do
+          it "passes" do
+            matcher.matches?(4).should be_true
           end
         end
 
-        context "with an unexpected error" do
-          let(:matcher) do
-            RSpec::Matchers::Matcher.new :foo do |expected|
-              match_unless_raises SyntaxError do |actual|
-                raise "unexpected exception"
-              end
-            end.for_expected(:bar)
+        context "with failing assertion" do
+          it "fails" do
+            matcher.matches?(5).should be_false
           end
 
-          it "raises the error" do
-            expect do
-              matcher.matches?(:bar)
-            end.to raise_error("unexpected exception")
+          it "provides the raised exception" do
+            matcher.matches?(5)
+            matcher.rescued_exception.message.
+              should eq("5 does not equal 4")
           end
         end
-
       end
 
-      it "can define chainable methods" do
-        matcher = RSpec::Matchers::Matcher.new(:name) do
-          chain(:expecting) do |expected_value|
-            @expected_value = expected_value
-          end
-          match { |actual| actual == @expected_value }
-        end.for_expected
+      context "with an unexpected error" do
+        let(:matcher) do
+          RSpec::Matchers::DSL::Matcher.new :foo do |expected|
+            match_unless_raises SyntaxError do |actual|
+              raise "unexpected exception"
+            end
+          end.for_expected(:bar)
+        end
 
-        matcher.expecting('value').matches?('value').should be_true
-        matcher.expecting('value').matches?('other value').should be_false
+        it "raises the error" do
+          expect do
+            matcher.matches?(:bar)
+          end.to raise_error("unexpected exception")
+        end
       end
 
-      it "prevents name collisions on chainable methods from different matchers" do
-        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")
-      end
+    end
 
-      context "defined using the dsl" do
-        def a_method_in_the_example
-          "method defined in the example"
+    it "can define chainable methods" do
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) do
+        chain(:expecting) do |expected_value|
+          @expected_value = expected_value
         end
+        match { |actual| actual == @expected_value }
+      end.for_expected
 
-        it "can access methods in the running example" do
-          RSpec::Matchers.define(:__access_running_example) do
-            match do |actual|
-              a_method_in_the_example == "method defined in the example"
-            end
+      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::DSL::Matcher.new(:m1) { chain(:foo) { raise "foo in m1" } }.for_expected
+      m2 = RSpec::Matchers::DSL::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")
+    end
+
+    context "defined using the dsl" do
+      def a_method_in_the_example
+        "method defined in the example"
+      end
+
+      it "can access methods in the running example" do
+        RSpec::Matchers.define(:__access_running_example) do
+          match do |actual|
+            a_method_in_the_example == "method defined in the example"
           end
-          example.should __access_running_example
         end
+        example.should __access_running_example
+      end
 
-        it "raises NoMethodError for methods not in the running_example" do
-          RSpec::Matchers.define(:__raise_no_method_error) do
-            match do |actual|
-              a_method_not_in_the_example == "method defined in the example"
-            end
+      it "raises NoMethodError for methods not in the running_example" do
+        RSpec::Matchers.define(:__raise_no_method_error) do
+          match do |actual|
+            a_method_not_in_the_example == "method defined in the example"
           end
-
-          expect do
-            example.should __raise_no_method_error
-          end.to raise_error(/RSpec::Matchers::Matcher/)
         end
+
+        expect do
+          example.should __raise_no_method_error
+        end.to raise_error(/RSpec::Matchers::DSL::Matcher/)
       end
-    
     end
+
   end
 end