rspec 1.1.11 → 1.1.12

data/lib/spec/matchers/be.rb

@@ -3,137 +3,115 @@ module Spec
     
     class Be #:nodoc:
       def initialize(*args)
-        if args.empty?
-          @expected = :satisfy_if
-        else
-          @expected = parse_expected(args.shift)
-        end
+        @expected = args.empty? ? true : set_expected(args.shift)
         @args = args
-        @comparison = ""
       end
       
-      def matches?(given)
-        @given = given
-        if handling_predicate?
-          begin
-            return @result = given.__send__(predicate, *@args)
-          rescue => predicate_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
+      def matches?(actual)
+        @actual = actual
+        handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual)
+      end
+      
+      def run_predicate_on(actual)
+        begin
+          return @result = actual.__send__(predicate, *@args)
+        rescue NameError => predicate_missing_error
+          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+        end
 
-          begin
-            return @result = given.__send__(present_tense_predicate, *@args)
-          rescue
-            raise predicate_error
-          end
-        else
-          return match_or_compare
+        begin
+          return @result = actual.__send__(present_tense_predicate, *@args)
+        rescue NameError
+          raise predicate_missing_error
         end
       end
       
       def failure_message
-        return "expected #{@comparison}#{expected}, got #{@given.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+        handling_predicate? ?
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" :
+          "expected #{@comparison_method} #{expected}, got #{@actual.inspect}".gsub('  ',' ')
       end
       
       def negative_failure_message
-        return "expected not #{expected}, got #{@given.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
-      end
-      
-      def expected
-        return "if to be satisfied" if @expected == :satisfy_if
-        return true if @expected == :true
-        return false if @expected == :false
-        return "nil" if @expected == :nil
-        return @expected.inspect
-      end
-      
-      def match_or_compare
-        return @given ? true : false if @expected == :satisfy_if
-        return @given == true if @expected == :true
-        return @given == false if @expected == :false
-        return @given.nil? if @expected == :nil
-        return @given < @expected if @less_than
-        return @given <= @expected if @less_than_or_equal
-        return @given >= @expected if @greater_than_or_equal
-        return @given > @expected if @greater_than
-        return @given == @expected if @double_equal
-        return @given === @expected if @triple_equal
-        return @given.equal?(@expected)
+        if handling_predicate?
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        else
+          message = <<-MESSAGE
+'should_not be #{@comparison_method} #{expected}' not only FAILED,
+it reads really poorly.
+          MESSAGE
+          
+          raise message << ([:===,:==].include?(@comparison_method) ?
+            "Why don't you try expressing it without the \"be\"?" :
+            "Why don't you try expressing it in the positive?")
+        end
       end
       
-      def ==(expected)
-        @prefix = "be "
-        @double_equal = true
-        @comparison = "== "
-        @expected = expected
-        self
-      end
-
-      def ===(expected)
-        @prefix = "be "
-        @triple_equal = true
-        @comparison = "=== "
-        @expected = expected
-        self
-      end
-
-      def <(expected)
-        @prefix = "be "
-        @less_than = true
-        @comparison = "< "
-        @expected = expected
-        self
-      end
-
-      def <=(expected)
-        @prefix = "be "
-        @less_than_or_equal = true
-        @comparison = "<= "
-        @expected = expected
-        self
+      def description
+        "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ')
       end
 
-      def >=(expected)
-        @prefix = "be "
-        @greater_than_or_equal = true
-        @comparison = ">= "
-        @expected = expected
-        self
+      [:==, :<, :<=, :>=, :>, :===].each do |method|
+        define_method method do |expected|
+          compare_to(expected, :using => method)
+          self
+        end
       end
 
-      def >(expected)
-        @prefix = "be "
-        @greater_than = true
-        @comparison = "> "
-        @expected = expected
-        self
-      end
+      private
+        def match_or_compare(actual)
+          case @expected
+          when TrueClass
+            @actual
+          else
+            @actual.__send__(comparison_method, @expected)
+          end
+        end
       
-      def description
-        "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}"
-      end
+        def comparison_method
+          @comparison_method || :equal?
+        end
+      
+        def expected
+          @expected
+        end
 
-      private
+        def compare_to(expected, opts)
+          @expected, @comparison_method = expected, opts[:using]
+        end
+
+        def set_expected(expected)
+          Symbol === expected ? parse_expected(expected) : expected
+        end
+        
         def parse_expected(expected)
-          if Symbol === expected
-            @handling_predicate = true
-            ["be_an_","be_a_","be_"].each do |prefix|
-              if expected.starts_with?(prefix)
-                @prefix = prefix
-                return "#{expected.to_s.sub(@prefix,"")}".to_sym
+          ["be_an_","be_a_","be_"].each do |prefix|
+            handling_predicate!
+            if expected.starts_with?(prefix)
+              set_prefix(prefix)
+              expected = expected.to_s.sub(prefix,"")
+              [true, false, nil].each do |val|
+                return val if val.to_s == expected
               end
+              return expected.to_sym
             end
           end
-          @prefix = ""
-          return expected
+        end
+        
+        def set_prefix(prefix)
+          @prefix = prefix
+        end
+        
+        def prefix
+          @prefix
+        end
+
+        def handling_predicate!
+          @handling_predicate = true
         end
         
         def handling_predicate?
-          return false if [:true, :false, :nil].include?(@expected)
+          return false if [true, false, nil].include?(expected)
           return @handling_predicate
         end
 
@@ -146,21 +124,27 @@ module Spec
         end
         
         def args_to_s
-          return "" if @args.empty?
-          inspected_args = @args.collect{|a| a.inspect}
-          return "(#{inspected_args.join(', ')})"
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+        
+        def parenthesize(string)
+          return "(#{string})"
+        end
+        
+        def inspected_args
+          @args.collect{|a| a.inspect}
         end
         
         def comparison
-          @comparison
+          @comparison_method.nil? ? " " : "be #{@comparison_method.to_s} "
         end
         
         def expected_to_sentence
-          split_words(@expected)
+          split_words(expected)
         end
         
         def prefix_to_sentence
-          split_words(@prefix)
+          split_words(prefix)
         end
 
         def split_words(sym)
@@ -181,7 +165,6 @@ module Spec
     end
  
     # :call-seq:
-    #   should be
     #   should be_true
     #   should be_false
     #   should be_nil
@@ -189,7 +172,7 @@ module Spec
     #   should_not be_nil
     #   should_not be_arbitrary_predicate(*args)
     #
-    # Given true, false, or nil, will pass if given value is
+    # Given true, false, or nil, will pass if actual value is
     # true, false or nil (respectively). Given no args means
     # the caller should satisfy an if condition (to be or not to be). 
     #
@@ -203,19 +186,23 @@ module Spec
     #
     # == Examples 
     #
-    #   target.should be
     #   target.should be_true
     #   target.should be_false
     #   target.should be_nil
     #   target.should_not be_nil
     #
     #   collection.should be_empty #passes if target.empty?
-    #   "this string".should be_an_intance_of(String)
-    #
     #   target.should_not be_empty #passes unless target.empty?
     #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
     def be(*args)
       Matchers::Be.new(*args)
     end
+
+    # passes if target.kind_of?(klass)
+    def be_a(klass)
+      be_a_kind_of(klass)
+    end
+    
+    alias_method :be_an, :be_a
   end
 end

data/lib/spec/matchers/be_close.rb

@@ -1,37 +1,21 @@
 module Spec
   module Matchers
 
-    class BeClose #:nodoc:
-      def initialize(expected, delta)
-        @expected = expected
-        @delta = delta
-      end
-      
-      def matches?(given)
-        @given = given
-        (@given - @expected).abs < @delta
-      end
-      
-      def failure_message
-        "expected #{@expected} +/- (< #{@delta}), got #{@given}"
-      end
-      
-      def description
-        "be close to #{@expected} (within +- #{@delta})"
-      end
-    end
-    
     # :call-seq:
     #   should be_close(expected, delta)
     #   should_not be_close(expected, delta)
     #
-    # Passes if given == expected +/- delta
+    # Passes if actual == expected +/- delta
     #
     # == Example
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      Matchers::BeClose.new(expected, delta)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message = "expected #{expected} +/- (< #{delta}), got #{actual}"
+        matcher.description = "be close to #{expected} (within +- #{delta})"
+        (actual - expected).abs < delta
+      end
     end
   end
 end

data/lib/spec/matchers/eql.rb

@@ -1,34 +1,11 @@
 module Spec
   module Matchers
   
-    class Eql #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-  
-      def matches?(given)
-        @given = given
-        @given.eql?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@given.inspect} (using .eql?)", @expected, @given
-      end
-      
-      def negative_failure_message
-        return "expected #{@given.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @given
-      end
-
-      def description
-        "eql #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
     #   should eql(expected)
     #   should_not eql(expected)
     #
-    # Passes if given and expected are of equal value, but not necessarily the same object.
+    # Passes if actual and expected are of equal value, but not necessarily the same object.
     #
     # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
     #
@@ -37,7 +14,12 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      Matchers::Eql.new(expected)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .eql?)", expected, actual
+        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .eql?)", expected, actual
+        matcher.description              = "eql #{expected.inspect}"
+        actual.eql?(expected)
+      end
     end
   end
 end

data/lib/spec/matchers/equal.rb

@@ -1,34 +1,11 @@
 module Spec
   module Matchers
   
-    class Equal #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-  
-      def matches?(given)
-        @given = given
-        @given.equal?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@given.inspect} (using .equal?)", @expected, @given
-      end
-
-      def negative_failure_message
-        return "expected #{@given.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @given
-      end
-      
-      def description
-        "equal #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
     #   should equal(expected)
     #   should_not equal(expected)
     #
-    # Passes if given and expected are the same object (object identity).
+    # Passes if actual and expected are the same object (object identity).
     #
     # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
     #
@@ -37,7 +14,12 @@ 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)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .equal?)", expected, actual
+        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .equal?)", expected, actual
+        matcher.description              = "equal #{expected.inspect}"
+        actual.equal?(expected)
+      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

@@ -1,22 +1,16 @@
 module Spec
   module Matchers
-    class Exist
-      def matches?(given)
-        @given = given
-        @given.exist?
-      end
-      def failure_message
-        "expected #{@given.inspect} to exist, but it doesn't."
-      end
-      def negative_failure_message
-        "expected #{@given.inspect} to not exist, but it does."
-      end
-    end
     # :call-seq:
     #   should exist
     #   should_not exist
     #
-    # Passes if given.exist?
-    def exist; Exist.new; end
+    # Passes if actual.exist?
+    def exist
+      simple_matcher do |actual, matcher|
+        matcher.failure_message = "expected #{actual.inspect} to exist, but it doesn't."
+        matcher.negative_failure_message = "expected #{actual.inspect} to not exist, but it does."
+        actual.exist?
+      end
+    end
   end
 end