rspec 1.0.0 → 1.3.1

data/lib/spec/matchers/change.rb

@@ -4,54 +4,59 @@ module Spec
     #Based on patch from Wilson Bilkovich
     class Change #:nodoc:
       def initialize(receiver=nil, message=nil, &block)
-        @receiver = receiver
-        @message = message
-        @block = block
+        @message = message || "result"
+        @value_proc = block || lambda {receiver.__send__(message)}
+        @to = @from = @minimum = @maximum = @amount = nil
       end
       
-      def matches?(target, &block)
-        if block
-          raise MatcherError.new(<<-EOF
-block passed to should or should_not change must use {} instead of do/end
-EOF
-)
-        end
-        @target = target
-        execute_change
-        return false if @from && (@from != @before)
-        return false if @to && (@to != @after)
+      def matches?(event_proc)
+        raise_block_syntax_error if block_given?
+        
+        @before = evaluate_value_proc
+        event_proc.call
+        @after = evaluate_value_proc
+        
+        return (@to = false) if @from unless @from == @before
+        return false if @to unless @to == @after
         return (@before + @amount == @after) if @amount
+        return ((@after - @before) >= @minimum) if @minimum
+        return ((@after - @before) <= @maximum) if @maximum        
         return @before != @after
       end
       
-      def execute_change
-        @before = @block.nil? ? @receiver.send(@message) : @block.call
-        @target.call
-        @after = @block.nil? ? @receiver.send(@message) : @block.call
+      def raise_block_syntax_error
+        raise MatcherError.new(<<-MESSAGE
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        )
+      end
+      
+      def evaluate_value_proc
+        @value_proc.call
       end
       
-      def failure_message
+      def failure_message_for_should
         if @to
-          "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+          "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
         elsif @from
-          "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+          "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
         elsif @amount
-          "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+          "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @minimum
+          "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @maximum
+          "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
         else
-          "#{result} should have changed, but is still #{@before.inspect}"
+          "#{@message} should have changed, but is still #{@before.inspect}"
         end
       end
       
-      def result
-        @message || "result"
-      end
-      
       def actual_delta
         @after - @before
       end
       
-      def negative_failure_message
-        "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+      def failure_message_for_should_not
+        "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
       end
       
       def by(amount)
@@ -59,6 +64,16 @@ EOF
         self
       end
       
+      def by_at_least(minimum)
+        @minimum = minimum
+        self
+      end
+      
+      def by_at_most(maximum)
+        @maximum = maximum
+        self
+      end      
+      
       def to(to)
         @to = to
         self
@@ -68,6 +83,10 @@ EOF
         @from = from
         self
       end
+      
+      def description
+        "change ##{@message}"
+      end
     end
     
     # :call-seq:
@@ -88,9 +107,17 @@ EOF
     #     team.add_player(player) 
     #   }.should change(roster, :count).by(1)
     #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count).by_at_least(1)
+    #
+    #   lambda {
+    #     team.add_player(player)
+    #   }.should change(roster, :count).by_at_most(1)    
+    #
     #   string = "string"
     #   lambda {
-    #     string.reverse
+    #     string.reverse!
     #   }.should change { string }.from("string").to("gnirts")
     #
     #   lambda {
@@ -101,20 +128,24 @@ EOF
     #     employee.develop_great_new_social_networking_app
     #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
     #
-    # Evaluates +receiver.message+ or +block+ before and
-    # after it evaluates the c object (generated by the lambdas in the examples above).
+    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after
+    # it evaluates the c object (generated by the lambdas in the examples
+    # above).
+    #
+    # Then compares the values before and after the <tt>receiver.message</tt>
+    # and evaluates the difference compared to the expected difference.
     #
-    # Then compares the values before and after the +receiver.message+ and
-    # evaluates the difference compared to the expected difference.
+    # == WARNING
+    # <tt>should_not change</tt> only supports the form with no
+    # subsequent calls to <tt>by</tt>, <tt>by_at_least</tt>,
+    # <tt>by_at_most</tt>, <tt>to</tt> or <tt>from</tt>.
     #
-    # == Warning
-    # +should_not+ +change+ only supports the form with no subsequent calls to
-    # +be+, +to+ or +from+.
+    # blocks passed to <tt>should</tt> <tt>change</tt> and <tt>should_not</tt>
+    # <tt>change</tt> must use the <tt>{}</tt> form (<tt>do/end</tt> is not
+    # supported).
     #
-    # blocks passed to +should+ +change+ and +should_not+ +change+
-    # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported)
-    def change(target=nil, message=nil, &block)
-      Matchers::Change.new(target, message, &block)
+    def change(receiver=nil, message=nil, &block)
+      Matchers::Change.new(receiver, message, &block)
     end
   end
 end

data/lib/spec/matchers/compatibility.rb

@@ -0,0 +1,14 @@
+Spec::Matchers.constants.each do |c|
+  if Class === (klass = Spec::Matchers.const_get(c))
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
+      klass.class_eval do
+        alias_method :failure_message, :failure_message_for_should
+      end
+    end
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
+      klass.class_eval do
+        alias_method :negative_failure_message, :failure_message_for_should_not
+      end
+    end
+  end
+end

data/lib/spec/matchers/dsl.rb

@@ -0,0 +1,20 @@
+module Spec
+  module Matchers
+    module DSL
+      # See Spec::Matchers
+      def define(name, &declarations)
+        define_method name do |*expected|
+          Spec::Matchers::Matcher.new name, *expected, &declarations
+        end
+      end
+      
+      # Deprecated - use define
+      def create(name, &declarations)
+        Spec.deprecate("Spec::Matchers.create","Spec::Matchers.define")
+        define(name, &declarations)
+      end
+    end
+  end
+end
+
+Spec::Matchers.extend Spec::Matchers::DSL

data/lib/spec/matchers/eql.rb

@@ -1,29 +1,5 @@
 module Spec
   module Matchers
-  
-    class Eql #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-  
-      def matches?(actual)
-        @actual = actual
-        @actual.eql?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
-      end
-      
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual
-      end
-
-      def description
-        "eql #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
     #   should eql(expected)
     #   should_not eql(expected)
@@ -37,7 +13,30 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      Matchers::Eql.new(expected)
+      Matcher.new :eql, expected do |_expected_|
+        match do |actual|
+          actual.eql?(_expected_)
+        end
+
+        failure_message_for_should do |actual|
+          <<-MESSAGE
+
+expected #{_expected_.inspect}
+     got #{actual.inspect}
+
+(compared using eql?)
+MESSAGE
+        end
+
+        failure_message_for_should_not do |actual|
+          <<-MESSAGE
+
+expected #{actual.inspect} not to equal #{_expected_.inspect}
+
+(compared using eql?)
+MESSAGE
+        end
+      end
     end
   end
-end
+end

data/lib/spec/matchers/equal.rb

@@ -1,29 +1,6 @@
 module Spec
   module Matchers
-  
-    class Equal #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-  
-      def matches?(actual)
-        @actual = actual
-        @actual.equal?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
-      end
 
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual
-      end
-      
-      def description
-        "equal #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
     #   should equal(expected)
     #   should_not equal(expected)
@@ -37,7 +14,40 @@ module Spec
     #   5.should equal(5) #Fixnums are equal
     #   "5".should_not equal("5") #Strings that look the same are not the same object
     def equal(expected)
-      Matchers::Equal.new(expected)
+      Matcher.new :equal, expected do |_expected_|
+        match do |actual|
+          actual.equal?(_expected_)
+        end
+        
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+        end
+        
+        failure_message_for_should do |actual|
+          <<-MESSAGE
+
+expected #{inspect_object(_expected_)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should == expected' if you don't care about
+object identity in this example.
+
+MESSAGE
+        end
+
+        failure_message_for_should_not do |actual|
+          <<-MESSAGE
+
+expected not #{inspect_object(actual)}
+         got #{inspect_object(_expected_)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
+        end
+      end
     end
   end
-end
+end

data/lib/spec/matchers/errors.rb

@@ -0,0 +1,5 @@
+module Spec
+  module Matchers
+    class MatcherError < StandardError; end
+  end
+end

data/lib/spec/matchers/exist.rb

@@ -0,0 +1,16 @@
+module Spec
+  module Matchers
+    # :call-seq:
+    #   should exist
+    #   should_not exist
+    #
+    # Passes if actual.exist?
+    def exist(arg=nil)
+      Matcher.new :exist do
+        match do |actual|
+          arg ? actual.exist?(arg) : actual.exist?
+        end
+      end
+    end
+  end
+end

data/lib/spec/matchers/generated_descriptions.rb

@@ -0,0 +1,36 @@
+module Spec
+  module Matchers
+    class << self
+      attr_accessor :last_matcher, :last_should # :nodoc:
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
+    end
+    
+  private
+    
+    def self.last_description
+      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
+When you call a matcher in an example without a String, like this:
+
+specify { object.should matcher }
+
+or this:
+
+it { should matcher }
+
+RSpec expects the matcher to have a #description method. You should either
+add a String to the example this matcher is being used in, or give it a
+description method. Then you won't have to suffer this lengthy warning again.
+MESSAGE
+    end
+  end
+end
+      

data/lib/spec/matchers/has.rb

@@ -1,44 +1,35 @@
 module Spec
   module Matchers
     
-    class Has #:nodoc:
-      def initialize(sym, *args)
-        @sym = sym
-        @args = args
+    class Has
+      
+      def initialize(expected, *args, &block)
+        @expected, @args, @block = expected, args, block
       end
       
-      def matches?(target)
-        @target = target
-        begin
-          return target.send(predicate, *@args)
-        rescue => @error
-          # This clause should be empty, but rcov will not report it as covered
-          # unless something (anything) is executed within the clause
-          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
-        end
-        return false
+      def matches?(actual)
+        actual.__send__(predicate(@expected), *@args, &@block)
       end
       
-      def failure_message
-        raise @error if @error
-        "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
+      def failure_message_for_should
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
       end
       
-      def negative_failure_message
-        raise @error if @error
-        "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
+      def failure_message_for_should_not
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
       end
       
       def description
         "have key #{@args[0].inspect}"
       end
+    
+    private
+    
+      def predicate(sym)
+        "#{sym.to_s.sub("have_","has_")}?".to_sym
+      end
       
-      private
-        def predicate
-          "#{@sym.to_s.sub("have_","has_")}?".to_sym
-        end
-        
     end
- 
+    
   end
 end

data/lib/spec/matchers/have.rb

@@ -1,10 +1,11 @@
 module Spec
   module Matchers
-    
     class Have #:nodoc:
       def initialize(expected, relativity=:exactly)
         @expected = (expected == :no ? 0 : expected)
         @relativity = relativity
+        @actual = nil
+        @plural_collection_name = nil
       end
     
       def relativities
@@ -15,61 +16,72 @@ module Spec
         }
       end
     
-      def method_missing(sym, *args, &block)
-        @collection_name = sym
-        @args = args
-        @block = block
-        self
-      end
-    
       def matches?(collection_owner)
-        if collection_owner.respond_to?(collection_name)
-          collection = collection_owner.send(collection_name, *@args, &@block)
+        if collection_owner.respond_to?(@collection_name)
+          collection = collection_owner.__send__(@collection_name, *@args, &@block)
+        elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
+          collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
         elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
           collection = collection_owner
         else
-          collection_owner.send(collection_name, *@args, &@block)
+          collection_owner.__send__(@collection_name, *@args, &@block)
         end
-        @actual = collection.length if collection.respond_to?(:length)
         @actual = collection.size if collection.respond_to?(:size)
+        @actual = collection.length if collection.respond_to?(:length)
+        raise not_a_collection if @actual.nil?
         return @actual >= @expected if @relativity == :at_least
         return @actual <= @expected if @relativity == :at_most
         return @actual == @expected
       end
+      
+      def not_a_collection
+        "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
+      end
     
-      def failure_message
-        "expected #{relative_expectation} #{collection_name}, got #{@actual}"
+      def failure_message_for_should
+        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
       end
 
-      def negative_failure_message
+      def failure_message_for_should_not
         if @relativity == :exactly
-          return "expected target not to have #{@expected} #{collection_name}, got #{@actual}"
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
         elsif @relativity == :at_most
           return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(#{@expected}).#{collection_name}
+  should_not have_at_most(#{@expected}).#{@collection_name}
 We recommend that you use this instead:
-  should have_at_least(#{@expected + 1}).#{collection_name}
+  should have_at_least(#{@expected + 1}).#{@collection_name}
 EOF
         elsif @relativity == :at_least
           return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(#{@expected}).#{collection_name}
+  should_not have_at_least(#{@expected}).#{@collection_name}
 We recommend that you use this instead:
-  should have_at_most(#{@expected - 1}).#{collection_name}
+  should have_at_most(#{@expected - 1}).#{@collection_name}
 EOF
         end
       end
       
       def description
-        "have #{relative_expectation} #{collection_name}"
+        "have #{relative_expectation} #{@collection_name}"
       end
       
+      def respond_to?(sym)
+        @expected.respond_to?(sym) || super
+      end
+    
       private
-      def collection_name
-        @collection_name
+      
+      def method_missing(sym, *args, &block)
+        @collection_name = sym
+        if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(sym.to_s)
+        end
+        @args = args
+        @block = block
+        self
       end
       
       def relative_expectation
@@ -137,4 +149,4 @@ EOF
       Matchers::Have.new(n, :at_most)
     end
   end
-end
+end

data/lib/spec/matchers/include.rb

@@ -1,52 +1,5 @@
 module Spec
   module Matchers
-
-    class Include #:nodoc:
-      
-      def initialize(*expecteds)
-        @expecteds = expecteds
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        @expecteds.each do |expected|
-          return false unless actual.include?(expected)
-        end
-        true
-      end
-      
-      def failure_message
-        _message
-      end
-      
-      def negative_failure_message
-        _message("not ")
-      end
-      
-      def description
-        "include #{_pretty_print(@expecteds)}"
-      end
-      
-      private
-        def _message(maybe_not="")
-          "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
-        end
-        
-        def _pretty_print(array)
-          result = ""
-          array.each_with_index do |item, index|
-            if index < (array.length - 2)
-              result << "#{item.inspect}, "
-            elsif index < (array.length - 1)
-              result << "#{item.inspect} and "
-            else
-              result << "#{item.inspect}"
-            end
-          end
-          result
-        end
-    end
-
     # :call-seq:
     #   should include(expected)
     #   should_not include(expected)
@@ -64,7 +17,28 @@ module Spec
     #   "spread".should include("read")
     #   "spread".should_not include("red")
     def include(*expected)
-      Matchers::Include.new(*expected)
+      Matcher.new :include, *expected do |*_expected_|
+        match do |actual|
+          helper(actual, *_expected_)
+        end
+        
+        def helper(actual, *_expected_)
+          _expected_.each do |expected|
+            if actual.is_a?(Hash)
+              if expected.is_a?(Hash)
+                expected.each_pair do |k,v|
+                  return false unless actual[k] == v
+                end
+              else
+                return false unless actual.has_key?(expected)
+              end
+            else
+              return false unless actual.include?(expected)
+            end
+          end
+          true
+        end
+      end
     end
   end
 end