rspec 1.1.12 → 1.2.0

data/lib/spec/interop/test.rb

@@ -1,3 +1,8 @@
+if Spec::Ruby.version.to_f >= 1.9
+  gem 'test-unit','1.2.3'
+end
+
+require 'spec'
 require 'test/unit'
 require 'test/unit/testresult'
 

data/lib/spec/interop/test/unit/testcase.rb

@@ -5,8 +5,7 @@ module Test
     # This extension of the standard Test::Unit::TestCase makes RSpec
     # available from within, so that you can do things like:
     #
-    # require 'test/unit'
-    # require 'spec'
+    # require 'spec/test/unit'
     #
     # class MyTest < Test::Unit::TestCase
     #   it "should work with Test::Unit assertions" do
@@ -41,33 +40,17 @@ module Test
       before(:each) {setup}
       after(:each) {teardown}
 
-      def initialize(defined_description, options={}, &implementation)
-        @_defined_description = defined_description
-        
-        # TODO - examples fail in rspec-rails if we remove "|| pending_implementation"
-        #      - find a way to fail without it in rspec's code examples
-        @_implementation = implementation || pending_implementation
-
-        @_result = ::Test::Unit::TestResult.new
-        # @method_name is important to set here because it complies with Test::Unit's interface.
+      def initialize(description, options={}, &implementation)
+        super
         # Some Test::Unit extensions depend on @method_name being present.
-        @method_name = @_defined_description
-
-        # TODO - this is necessary to run single examples in rspec-rails, but I haven't
-        # found a good way to write a failing example just within rspec core
-        @_backtrace = caller
+        @method_name = description
+        @_result = ::Test::Unit::TestResult.new
       end
 
       def run(ignore_this_argument=nil)
         super()
       end
 
-    private
-
-      def pending_implementation
-        error = Spec::Example::NotYetImplementedError.new(caller)
-        lambda { raise(error) }
-      end
     end
   end
 end

data/lib/spec/matchers.rb

@@ -1,24 +1,29 @@
+require 'spec/matchers/extensions/instance_exec'
+require 'spec/matchers/matcher'
 require 'spec/matchers/operator_matcher'
-require 'spec/matchers/generated_descriptions'
-require 'spec/matchers/errors'
-require 'spec/matchers/method_missing'
-require 'spec/matchers/simple_matcher'
 require 'spec/matchers/be'
 require 'spec/matchers/be_close'
+require 'spec/matchers/be_instance_of'
+require 'spec/matchers/be_kind_of'
 require 'spec/matchers/change'
-require 'spec/matchers/match_array'
 require 'spec/matchers/eql'
 require 'spec/matchers/equal'
+require 'spec/matchers/errors'
 require 'spec/matchers/exist'
+require 'spec/matchers/generated_descriptions'
 require 'spec/matchers/has'
 require 'spec/matchers/have'
 require 'spec/matchers/include'
 require 'spec/matchers/match'
+require 'spec/matchers/match_array'
+require 'spec/matchers/method_missing'
 require 'spec/matchers/raise_error'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
+require 'spec/matchers/simple_matcher'
 require 'spec/matchers/throw_symbol'
 require 'spec/matchers/wrap_expectation'
+require 'spec/matchers/compatibility'
 
 module Spec
 
@@ -26,12 +31,21 @@ module Spec
   # is any object that responds to the following methods:
   #
   #   matches?(actual)
-  #   failure_message
-  #   negative_failure_message #optional
+  #   failure_message_for_should
+  #
+  # These methods are also part of the matcher protocol, but are optional:
+  #
+  #   does_not_match?(actual)
+  #   failure_message_for_should_not
   #   description #optional
   #
+  # These methods are from older versions of the protocol. They are still supported,
+  # but are not recommended:
+  #
+  #   failure_message          (use failure_message_for_should instead)
+  #   negative_failure_message (use failure_message_for_should_not instead)
+  #
   # See Spec::Expectations to learn how to use these as Expectation Matchers.
-  # See Spec::Mocks to learn how to use them as Mock Argument Constraints.
   #
   # == Predicates
   #

data/lib/spec/matchers/be.rb

@@ -26,13 +26,13 @@ module Spec
         end
       end
       
-      def failure_message
+      def failure_message_for_should
         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
+      def failure_message_for_should_not
         if handling_predicate?
           "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
         else
@@ -60,12 +60,7 @@ it reads really poorly.
 
       private
         def match_or_compare(actual)
-          case @expected
-          when TrueClass
-            @actual
-          else
-            @actual.__send__(comparison_method, @expected)
-          end
+          TrueClass === @expected ? @actual : @actual.__send__(comparison_method, @expected)
         end
       
         def comparison_method
@@ -87,7 +82,7 @@ it reads really poorly.
         def parse_expected(expected)
           ["be_an_","be_a_","be_"].each do |prefix|
             handling_predicate!
-            if expected.starts_with?(prefix)
+            if expected.to_s =~ /^#{prefix}/
               set_prefix(prefix)
               expected = expected.to_s.sub(prefix,"")
               [true, false, nil].each do |val|

data/lib/spec/matchers/be_close.rb

@@ -1,5 +1,24 @@
 module Spec
   module Matchers
+    
+    class BeClose
+      def initialize(expected, delta)
+        @expected, @delta = expected, delta
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        (@actual - @expected).abs < @delta
+      end
+      
+      def failure_message_for_should
+        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
+      end
+      
+      def description
+        "be close to #{@expected} (within +- #{@delta})"
+      end
+    end
 
     # :call-seq:
     #   should be_close(expected, delta)
@@ -11,11 +30,7 @@ module Spec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(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
+      BeClose.new(expected, delta)
     end
   end
 end

data/lib/spec/matchers/be_instance_of.rb

@@ -0,0 +1,45 @@
+module Spec
+  module Matchers
+    class BeInstanceOf
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.instance_of?(@expected)
+      end
+      
+      def description
+        "be an instance of #{@expected}"
+      end
+      
+      def failure_message_for_should
+        "expected instance of #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} not to be an instance of #{@expected}"
+      end
+    end
+
+    # :call-seq:
+    #   should be_instance_of(expected)
+    #   should be_an_instance_of(expected)
+    #   should_not be_instance_of(expected)
+    #   should_not be_an_instance_of(expected)
+    #
+    # Passes if actual.instance_of?(expected)
+    #
+    # == Examples
+    #
+    #   5.should be_instance_of(Fixnum)
+    #   5.should_not be_instance_of(Numeric)
+    #   5.should_not be_instance_of(Float)
+    def be_instance_of(expected)
+      BeInstanceOf.new(expected)
+    end
+    
+    alias_method :be_an_instance_of, :be_instance_of
+  end
+end

data/lib/spec/matchers/be_kind_of.rb

@@ -0,0 +1,45 @@
+module Spec
+  module Matchers
+    class BeKindOf
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.kind_of?(@expected)
+      end
+      
+      def description
+        "be a kind of #{@expected}"
+      end
+      
+      def failure_message_for_should
+        "expected kind of #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} not to be a kind of #{@expected}"
+      end
+    end
+
+    # :call-seq:
+    #   should be_kind_of(expected)
+    #   should be_a_kind_of(expected)
+    #   should_not be_kind_of(expected)
+    #   should_not be_a_kind_of(expected)
+    #
+    # Passes if actual.kind_of?(expected)
+    #
+    # == Examples
+    #
+    #   5.should be_kind_of(Fixnum)
+    #   5.should be_kind_of(Numeric)
+    #   5.should_not be_kind_of(Float)
+    def be_kind_of(expected)
+      BeKindOf.new(expected)
+    end
+    
+    alias_method :be_a_kind_of, :be_kind_of
+  end
+end

data/lib/spec/matchers/change.rb

@@ -5,9 +5,7 @@ module Spec
     class Change #:nodoc:
       def initialize(receiver=nil, message=nil, &block)
         @message = message || "result"
-        @value_proc = block || lambda {
-          receiver.__send__(message)
-        }
+        @value_proc = block || lambda {receiver.__send__(message)}
       end
       
       def matches?(event_proc)
@@ -17,7 +15,7 @@ module Spec
         event_proc.call
         @after = evaluate_value_proc
         
-        return false if @from unless @from == @before
+        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
@@ -36,7 +34,7 @@ MESSAGE
         @value_proc.call
       end
       
-      def failure_message
+      def failure_message_for_should
         if @to
           "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
         elsif @from
@@ -56,7 +54,7 @@ MESSAGE
         @after - @before
       end
       
-      def negative_failure_message
+      def failure_message_for_should_not
         "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
       end
       
@@ -84,6 +82,10 @@ MESSAGE
         @from = from
         self
       end
+      
+      def description
+        "change ##{@message}"
+      end
     end
     
     # :call-seq:

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.include?('failure_message_for_should')
+      klass.class_eval do
+        alias_method :failure_message, :failure_message_for_should
+      end
+    end
+    if klass.public_instance_methods.include?('failure_message_for_should_not')
+      klass.class_eval do
+        alias_method :negative_failure_message, :failure_message_for_should_not
+      end
+    end
+  end
+end

data/lib/spec/matchers/eql.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    class Eql
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.eql?(@expected)
+      end
+      
+      def failure_message_for_should
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
+      end
+      
+      def failure_message_for_should_not
+        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)
@@ -14,12 +37,7 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(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
+      Eql.new(expected)
     end
   end
 end

data/lib/spec/matchers/equal.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    
+    class Equal
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.equal?(@expected)
+      end
+      
+      def failure_message_for_should
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
+      end
+      
+      def failure_message_for_should_not
+        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)
@@ -14,12 +37,7 @@ 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)
-      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
+      Equal.new(expected)
     end
   end
 end

data/lib/spec/matchers/exist.rb

@@ -1,16 +1,32 @@
 module Spec
   module Matchers
+
+    class Exist
+      def matches?(actual)
+        @actual = actual
+        actual.exist?
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to exist, but it doesn't."
+      end
+
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} to not exist, but it does."
+      end
+
+      def description
+        "exists"
+      end
+    end
+
     # :call-seq:
     #   should exist
     #   should_not exist
     #
     # 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
+      Exist.new
     end
   end
 end