rspec-expectations 2.0.0.rc → 2.0.0

data/features/step_definitions/additional_cli_steps.rb

@@ -5,3 +5,9 @@ Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
   end
 end
 
+Then /^the output should contain all of these:$/ do |table|
+  table.raw.flatten.each do |string|
+    assert_partial_output(string)
+  end
+end
+

data/lib/rspec/expectations/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Expectations # :nodoc:
     module Version # :nodoc:
-      STRING = '2.0.0.rc'
+      STRING = '2.0.0'
     end
   end
 end

data/lib/rspec/matchers/include.rb

@@ -18,10 +18,18 @@ module RSpec
     #   "spread".should_not include("red")
     def include(*expected)
       Matcher.new :include, *expected do |*_expected|
-        match do |actual|
-          _expected.all? do |expected|
+        match_for_should do |actual|
+          perform_match(:all?, :all?, actual, _expected)
+        end
+
+        match_for_should_not do |actual|
+          perform_match(:none?, :any?, actual, _expected)
+        end
+
+        def perform_match(predicate, hash_predicate, actual, _expected)
+          _expected.send(predicate) do |expected|
             if comparing_hash_values?(actual, expected)
-              expected.all? {|k,v| actual[k] == v}
+              expected.send(hash_predicate) {|k,v| actual[k] == v}
             elsif comparing_hash_keys?(actual, expected)
               actual.has_key?(expected)
             else
@@ -37,9 +45,7 @@ module RSpec
         def comparing_hash_values?(actual, expected) # :nodoc:
           actual.is_a?(Hash) && expected.is_a?(Hash)
         end
-
       end
-
     end
   end
 end

data/lib/rspec/matchers/matcher.rb

@@ -22,7 +22,7 @@ module RSpec
         end
       end
       
-      #Used internally by objects returns by +should+ and +should_not+.
+      #Used internally by +should+ and +should_not+.
       def matches?(actual)
         @actual = actual
         if @expected_exception
@@ -41,10 +41,28 @@ module RSpec
         end
       end
 
+      # Used internally by +should_not+
+      def does_not_match?(actual)
+        @actual = actual
+        @match_for_should_not_block ?
+          instance_exec(actual, &@match_for_should_not_block) :
+          !matches?(actual)
+      end
+
+      def define_method(name, &block) # :nodoc:
+        singleton_class.__send__(:define_method, name, &block)
+      end
+
       # See RSpec::Matchers
       def match(&block)
         @match_block = block
       end
+      alias match_for_should match
+
+      # See RSpec::Matchers
+      def match_for_should_not(&block)
+        @match_for_should_not_block = block
+      end
 
       # See RSpec::Matchers
       def match_unless_raises(exception=Exception, &block)
@@ -110,8 +128,7 @@ module RSpec
         # cause features to fail and that will make users unhappy. So don't.
         orig_private_methods = private_methods
         yield
-        st = (class << self; self; end)
-        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
+        (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
       end
 
       def cache_or_call_cached(key, &block)
@@ -134,6 +151,11 @@ module RSpec
         to_sentence(@expected)
       end
 
+      unless method_defined?(:singleton_class)
+        def singleton_class
+          class << self; self; end
+        end
+      end
     end
   end
 end

data/lib/rspec/matchers/respond_to.rb

@@ -5,23 +5,22 @@ module RSpec
       def initialize(*names)
         @names = names
         @expected_arity = nil
-        @names_not_responded_to = []
       end
       
       def matches?(actual)
-        @actual = actual
-        @names.each do |name|
-          @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name)
-        end
-        return @names_not_responded_to.empty?
+        find_failing_method_names(actual, :reject).empty?
+      end
+
+      def does_not_match?(actual)
+        find_failing_method_names(actual, :select).empty?
       end
       
       def failure_message_for_should
-        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
       end
       
       def failure_message_for_should_not
-        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+        failure_message_for_should.sub(/to respond to/, 'not to respond to')
       end
       
       def description
@@ -39,9 +38,24 @@ module RSpec
       alias :arguments :argument
       
     private
+
+      def find_failing_method_names(actual, filter_method)
+        @actual = actual
+        @failing_method_names = @names.send(filter_method) do |name|
+          @actual.respond_to?(name) && matches_arity?(actual, name)
+        end
+      end
       
       def matches_arity?(actual, name)
-        @expected_arity.nil?? true : @expected_arity == actual.method(name).arity 
+        return true unless @expected_arity
+
+        actual_arity = actual.method(name).arity
+        if actual_arity < 0
+          # ~ inverts the one's complement and gives us the number of required args
+          ~actual_arity <= @expected_arity
+        else
+          actual_arity == @expected_arity
+        end
       end
       
       def with_arity

data/spec/rspec/matchers/include_spec.rb

@@ -1,88 +1,341 @@
 require 'spec_helper'
 
 describe "should include(expected)" do
-  it "passes if target includes expected" do
-    [1,2,3].should include(3)
-    "abc".should include("a")
-  end
-  
-  it 'passes if target is a Hash and has the expected as a key' do
-    {:key => 'value'}.should include(:key)
-  end
-
-  it "fails if target does not include expected" do
-    lambda {
-      [1,2,3].should include(4)
-    }.should fail_with("expected [1, 2, 3] to include 4")
-    lambda {
-      "abc".should include("d")
-    }.should fail_with("expected \"abc\" to include \"d\"")
-    lambda {
-      {:key => 'value'}.should include(:other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :other|)
+  context "for a string target" do
+    it "passes if target includes expected" do
+      "abc".should include("a")
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        "abc".should include("d")
+      }.should fail_with("expected \"abc\" to include \"d\"")
+    end
+  end
+
+  context "for an array target" do
+    it "passes if target includes expected" do
+      [1,2,3].should include(3)
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        [1,2,3].should include(4)
+      }.should fail_with("expected [1, 2, 3] to include 4")
+    end
+  end
+
+  context "for a hash target" do
+    it 'passes if target has the expected as a key' do
+      {:key => 'value'}.should include(:key)
+    end
+
+    it "fails if target does not include expected" do
+      lambda {
+        {:key => 'value'}.should include(:other)
+      }.should fail_with(%Q|expected {:key=>"value"} to include :other|)
+    end
   end
 end
 
 describe "should include(with, multiple, args)" do
-  it "passes if target includes all items" do
-    [1,2,3].should include(1,2,3)
-  end
-  
-  it 'passes if target is a Hash including all items as keys' do
-    {:key => 'value', :other => 'value'}.should include(:key, :other)
+  context "for a string target" do
+    it "passes if target includes all items" do
+      "a string".should include("str", "a")
+    end
+
+    it "fails if target does not include any one of the items" do
+      lambda {
+        "a string".should include("str", "a", "foo")
+      }.should fail_with(%Q{expected "a string" to include "str", "a", and "foo"})
+    end
   end
 
-  it "fails if target does not include any one of the items" do
-    lambda {
-      [1,2,3].should include(1,2,4)
-    }.should fail_with("expected [1, 2, 3] to include 1, 2, and 4")
+  context "for an array target" do
+    it "passes if target includes all items" do
+      [1,2,3].should include(1,2,3)
+    end
+
+    it "fails if target does not include any one of the items" do
+      lambda {
+        [1,2,3].should include(1,2,4)
+      }.should fail_with("expected [1, 2, 3] to include 1, 2, and 4")
+    end
   end
-  
-  it 'passes if target is a Hash missing any item as a key' do
-    lambda {
-      {:key => 'value'}.should include(:key, :other)
-    }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|)
+
+  context "for a hash target" do
+    it 'passes if target includes all items as keys' do
+      {:key => 'value', :other => 'value'}.should include(:key, :other)
+    end
+
+    it 'fails if target is missing any item as a key' do
+      lambda {
+        {:key => 'value'}.should include(:key, :other)
+      }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|)
+    end
   end
 end
 
 describe "should_not include(expected)" do
-  it "passes if target does not include expected" do
-    [1,2,3].should_not include(4)
-    "abc".should_not include("d")
-  end
-  
-  it 'passes if target is a Hash and does not have the expected as a key' do
-    {:other => 'value'}.should_not include(:key)
-  end
-
-  it "fails if target includes expected" do
-    lambda {
-      [1,2,3].should_not include(3)
-    }.should fail_with("expected [1, 2, 3] not to include 3")
-    lambda {
-      "abc".should_not include("c")
-    }.should fail_with("expected \"abc\" not to include \"c\"")
-    lambda {
-      {:key => 'value'}.should_not include(:key)
-    }.should fail_with(%Q|expected {:key=>"value"} not to include :key|)
+  context "for a string target" do
+    it "passes if target does not include expected" do
+      "abc".should_not include("d")
+    end
+
+    it "fails if target includes expected" do
+      lambda {
+        "abc".should_not include("c")
+      }.should fail_with("expected \"abc\" not to include \"c\"")
+    end
+  end
+
+  context "for an array target" do
+    it "passes if target does not include expected" do
+      [1,2,3].should_not include(4)
+    end
+
+    it "fails if target includes expected" do
+      lambda {
+        [1,2,3].should_not include(3)
+      }.should fail_with("expected [1, 2, 3] not to include 3")
+    end
+  end
+
+  context "for a hash target" do
+    it 'passes if target does not have the expected as a key' do
+      {:other => 'value'}.should_not include(:key)
+    end
+
+    it "fails if target includes expected key" do
+      lambda {
+        {:key => 'value'}.should_not include(:key)
+      }.should fail_with(%Q|expected {:key=>"value"} not to include :key|)
+    end
+  end
+
+end
+
+describe "should_not include(with, multiple, args)" do
+  context "for a string target" do
+    it "passes if the target does not include any of the expected" do
+      "abc".should_not include("d", "e", "f")
+    end
+
+    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"})
+    end
+
+    it "fails if the target includes some (but not all) of the expected" do
+      expect {
+        "abc".should_not include("d", "a")
+      }.to fail_with(%q{expected "abc" not to include "d" and "a"})
+    end
+  end
+
+  context "for a hash target" do
+    it "passes if it does not include any of the expected keys" do
+      { :a => 1, :b => 2 }.should_not include(:c, :d)
+    end
+
+    it "fails if the target includes all of the expected keys" do
+      expect {
+        { :a => 1, :b => 2 }.should_not include(:a, :b)
+      }.to fail_with(%q|expected {:a=>1, :b=>2} not to include :a and :b|)
+    end
+
+    it "fails if the target includes some (but not all) of the expected keys" do
+      expect {
+        { :a => 1, :b => 2 }.should_not include(:d, :b)
+      }.to fail_with(%q|expected {:a=>1, :b=>2} not to include :d and :b|)
+    end
+  end
+
+  context "for an array target" do
+    it "passes if the target does not include any of the expected" do
+      [1, 2, 3].should_not include(4, 5, 6)
+    end
+
+    it "fails if the target includes all of the expected" do
+      expect {
+        [1, 2, 3].should_not include(3, 1)
+      }.to fail_with(%q{expected [1, 2, 3] not to include 3 and 1})
+    end
+
+    it "fails if the target includes some (but not all) of the expected" do
+      expect {
+        [1, 2, 3].should_not include(4, 1)
+      }.to fail_with(%q{expected [1, 2, 3] not to include 4 and 1})
+    end
   end
 end
 
 describe "should include(:key => value)" do
-  it "passes if target is a Hash and includes the key/value pair" do
-    {:key => 'value'}.should include(:key => 'value')
+  context 'for a hash target' do
+    it "passes if target includes the key/value pair" do
+      {:key => 'value'}.should include(:key => 'value')
+    end
+
+    it "passes if target includes the key/value pair among others" do
+      {:key => 'value', :other => 'different'}.should include(:key => 'value')
+    end
+
+    it "fails if target has a different value for key" do
+      lambda {
+        {:key => 'different'}.should include(:key => 'value')
+      }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
+    end
+
+    it "fails if target has a different key" do
+      lambda {
+        {:other => 'value'}.should include(:key => 'value')
+      }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|)
+    end
   end
-  it "passes if target is a Hash and includes the key/value pair among others" do
-    {:key => 'value', :other => 'different'}.should include(:key => 'value')
+
+  context 'for a non-hash target' do
+    it "fails if the target does not contain the given hash" do
+      lambda {
+        ['a', 'b'].should include(:key => 'value')
+      }.should fail_with(%q|expected ["a", "b"] to include {:key=>"value"}|)
+    end
+
+    it "passes if the target contains the given hash" do
+      ['a', { :key => 'value' } ].should include(:key => 'value')
+    end
   end
-  it "fails if target is a Hash and has a different value for key" do
-    lambda {
-      {:key => 'different'}.should include(:key => 'value')
-    }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
+end
+
+describe "should_not include(:key => value)" do
+  context 'for a hash target' do
+    it "fails if target includes the key/value pair" do
+      lambda {
+        {:key => 'value'}.should_not include(:key => 'value')
+      }.should fail_with(%Q|expected {:key=>"value"} not to include {:key=>"value"}|)
+    end
+
+    it "fails if target includes the key/value pair among others" do
+      lambda {
+        {:key => 'value', :other => 'different'}.should_not include(:key => 'value')
+      }.should fail_with(%Q|expected {:key=>"value", :other=>"different"} not to include {:key=>"value"}|)
+    end
+
+    it "passes if target has a different value for key" do
+      {:key => 'different'}.should_not include(:key => 'value')
+    end
+
+    it "passes if target has a different key" do
+      {:other => 'value'}.should_not include(:key => 'value')
+    end
   end
-  it "fails if target is a Hash and has a different key" do
-    lambda {
-      {:other => 'value'}.should include(:key => 'value')
-    }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|)
+
+  context "for a non-hash target" do
+    it "passes if the target does not contain the given hash" do
+      ['a', 'b'].should_not include(:key => 'value')
+    end
+
+    it "fails if the target contains the given hash" do
+      lambda {
+        ['a', { :key => 'value' } ].should_not include(:key => 'value')
+      }.should fail_with(%Q|expected ["a", {:key=>"value"}] not to include {:key=>"value"}|)
+    end
+  end
+end
+
+describe "should include(:key1 => value1, :key2 => value2)" do
+  context 'for a hash target' do
+    it "passes if target includes the key/value pairs" do
+      {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
+    end
+
+    it "passes if target includes the key/value pairs among others" do
+      {:a => 1, :c => 3, :b => 2}.should include(:b => 2, :a => 1)
+    end
+
+    it "fails if target has a different value for one of the keys" do
+      lambda {
+        {:a => 1, :b => 2}.should include(:a => 2, :b => 2)
+      }.should fail_with(%Q|expected {:a=>1, :b=>2} to include {:a=>2, :b=>2}|)
+    end
+
+    it "fails if target has a different value for both of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:a => 2, :b => 2)
+      }.should fail_with(%Q|expected {:a=>1, :b=>1} to include {:a=>2, :b=>2}|)
+    end
+
+    it "fails if target lacks one of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:a => 1, :c => 1)
+      }.should fail_with(%Q|expected {:a=>1, :b=>1} to include {:a=>1, :c=>1}|)
+    end
+
+    it "fails if target lacks both of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should include(:c => 1, :d => 1)
+      }.should fail_with(%Q|expected {:a=>1, :b=>1} to include {:c=>1, :d=>1}|)
+    end
+  end
+
+  context 'for a non-hash target' do
+    it "fails if the target does not contain the given hash" do
+      lambda {
+        ['a', 'b'].should include(:a => 1, :b => 1)
+      }.should fail_with(%q|expected ["a", "b"] to include {:a=>1, :b=>1}|)
+    end
+
+    it "passes if the target contains the given hash" do
+      ['a', { :a => 1, :b => 2 } ].should include(:a => 1, :b => 2)
+    end
+  end
+end
+
+describe "should_not include(:key1 => value1, :key2 => value2)" do
+  context 'for a hash target' do
+    it "fails if target includes the key/value pairs" do
+      lambda {
+        {:a => 1, :b => 2}.should_not include(:a => 1, :b => 2)
+      }.should fail_with(%Q|expected {:a=>1, :b=>2} not to include {:a=>1, :b=>2}|)
+    end
+
+    it "fails if target includes the key/value pairs among others" do
+      hash = {:a => 1, :b => 2, :c => 3}
+      lambda {
+        hash.should_not include(:a => 1, :b => 2)
+      }.should fail_with(%Q|expected #{hash.inspect} not to include {:a=>1, :b=>2}|)
+    end
+
+    it "fails if target has a different value for one of the keys" do
+      lambda {
+        {:a => 1, :b => 2}.should_not include(:a => 2, :b => 2)
+      }.should fail_with(%Q|expected {:a=>1, :b=>2} not to include {:a=>2, :b=>2}|)
+    end
+
+    it "passes if target has a different value for both of the keys" do
+      {:a => 1, :b => 1}.should_not include(:a => 2, :b => 2)
+    end
+
+    it "fails if target lacks one of the keys" do
+      lambda {
+        {:a => 1, :b => 1}.should_not include(:a => 1, :c => 1)
+      }.should fail_with(%Q|expected {:a=>1, :b=>1} not to include {:a=>1, :c=>1}|)
+    end
+
+    it "passes if target lacks both of the keys" do
+      {:a => 1, :b => 1}.should_not include(:c => 1, :d => 1)
+    end
+  end
+
+  context 'for a non-hash target' do
+    it "passes if the target does not contain the given hash" do
+      ['a', 'b'].should_not include(:a => 1, :b => 1)
+    end
+
+    it "fails if the target contains the given hash" do
+      lambda {
+        ['a', { :a => 1, :b => 2 } ].should_not include(:a => 1, :b => 2)
+      }.should fail_with(%Q|expected ["a", {:a=>1, :b=>2}] not to include {:a=>1, :b=>2}|)
+    end
   end
 end