rspec 0.5.16 → 0.6.0

data/lib/spec/runner/instance_exec.rb

@@ -1,14 +1,20 @@
-# http://eigenclass.org/hiki.rb?cmd=view&p=instance_exec&key=instance_exec
+# http://eigenclass.org/hiki.rb?bounded+space+instance_exec
 class Object
   module InstanceExecHelper; end
   include InstanceExecHelper
-  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
-    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
-    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+  def instance_exec(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
     begin
       ret = send(mname, *args)
     ensure
-      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
     end
     ret
   end

data/lib/spec/version.rb

@@ -2,8 +2,8 @@ module Spec
   module VERSION
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 5
-      TINY   = 16
+      MINOR  = 6
+      TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')

data/test/spec/api/helper/arbitrary_predicate_test.rb

@@ -6,18 +6,18 @@ module Spec
 
       class ArbitraryPredicateTest < Test::Unit::TestCase
 
-        # should.be.funny
+        # should_be_funny
 
         def test_should_be_funny_should_raise_when_target_doesnt_understand_funny
           assert_raise(NoMethodError) do
-            5.should.be.funny
+            5.should_be_funny
           end
         end
 
         def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_false
           mock = HandCodedMock.new(false)
           assert_raise(ExpectationNotMetError) do
-            mock.should.be.funny
+            mock.should_be_funny
           end
           mock.__verify
         end
@@ -25,7 +25,7 @@ module Spec
         def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_nil
           mock = HandCodedMock.new(nil)
           assert_raise(ExpectationNotMetError) do
-            mock.should.be.funny
+            mock.should_be_funny
           end
           mock.__verify
         end
@@ -33,7 +33,7 @@ module Spec
         def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_true
           mock = HandCodedMock.new(true)
           assert_nothing_raised do
-            mock.should.be.funny
+            mock.should_be_funny
           end
           mock.__verify
         end
@@ -41,33 +41,33 @@ module Spec
         def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
           mock = HandCodedMock.new(5)
           assert_nothing_raised do
-            mock.should.be.funny
+            mock.should_be_funny
           end
           mock.__verify
         end
 
-        # should.be.funny(args)
+        # should_be_funny(args)
   
         def test_should_be_funny_with_args_passes_args_properly
            mock = HandCodedMock.new(true)
           assert_nothing_raised do
-            mock.should.be.hungry(1, 2, 3)
+            mock.should_be_hungry(1, 2, 3)
           end
           mock.__verify
         end
 
-        # should.not.be.funny
+        # should_not_be_funny
 
         def test_should_not_be_funny_should_raise_when_target_doesnt_understand_funny
           assert_raise(NoMethodError) do
-            5.should.not.be.funny
+            5.should_not_be_funny
           end
         end
 
         def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_true
           mock = HandCodedMock.new(true)
           assert_raise(ExpectationNotMetError) do
-            mock.should.not.be.funny
+            mock.should_not_be_funny
           end
           mock.__verify
         end
@@ -75,7 +75,7 @@ module Spec
         def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_nil
           mock = HandCodedMock.new(nil)
           assert_nothing_raised do
-            mock.should.not.be.funny
+            mock.should_not_be_funny
           end
           mock.__verify
         end
@@ -83,7 +83,7 @@ module Spec
         def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_false
           mock = HandCodedMock.new(false)
           assert_nothing_raised do
-            mock.should.not.be.funny
+            mock.should_not_be_funny
           end
           mock.__verify
         end
@@ -91,17 +91,17 @@ module Spec
         def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
           mock = HandCodedMock.new(5)
           assert_raise(ExpectationNotMetError) do
-            mock.should.not.be.funny
+            mock.should_not_be_funny
           end
           mock.__verify
         end
   
-        # should.be.funny(args)
+        # should_be_funny(args)
   
         def test_should_not_be_funny_with_args_passes_args_properly
            mock = HandCodedMock.new(false)
           assert_nothing_raised do
-            mock.should.not.be.hungry(1, 2, 3)
+            mock.should_not_be_hungry(1, 2, 3)
           end
           mock.__verify
         end

data/test/spec/api/helper/containment_test.rb

@@ -16,49 +16,49 @@ module Spec
   
         def test_should_include_shouldnt_raise_when_string_inclusion_is_present
           assert_nothing_raised do
-            @dummy.should.include "mm"
+            @dummy.should_include "mm"
           end
         end
   
         def test_should_include_should_raise_when_string_inclusion_is_missing
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.include "abc" 
+            @dummy.should_include "abc" 
           end
         end
 
         def test_should_include_shouldnt_raise_when_array_inclusion_is_present
           assert_nothing_raised do
-            [1, 2, 3].should.include 2
+            [1, 2, 3].should_include 2
           end
         end
 
         def test_should_include_should_raise_when_array_inclusion_is_missing
           assert_raise(ExpectationNotMetError) do
-            [1, 2, 3].should.include 5
+            [1, 2, 3].should_include 5
           end
         end
 
         def test_should_include_shouldnt_raise_when_hash_inclusion_is_present
           assert_nothing_raised do
-            {"a"=>1}.should.include "a"
+            {"a"=>1}.should_include "a"
           end
         end
 
         def test_should_include_should_raise_when_hash_inclusion_is_missing
           assert_raise(ExpectationNotMetError) do
-            {"a"=>1}.should.include "b"
+            {"a"=>1}.should_include "b"
           end
         end
 
         def test_should_include_shouldnt_raise_when_enumerable_inclusion_is_present
           assert_nothing_raised do
-            IO.constants.should.include "SEEK_SET"
+            IO.constants.should_include "SEEK_SET"
           end
         end
 
         def test_should_include_should_raise_when_enumerable_inclusion_is_missing
           assert_raise(ExpectationNotMetError) do
-            IO.constants.should.include "BLAH"
+            IO.constants.should_include "BLAH"
           end
         end
   
@@ -66,49 +66,49 @@ module Spec
   
         def test_should_not_include_shouldnt_raise_when_string_inclusion_is_missing
           assert_nothing_raised do
-            @dummy.should.not.include "abc"
+            @dummy.should_not_include "abc"
           end
         end
 
         def test_should_not_include_should_raise_when_string_inclusion_is_present
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.not.include "mm"
+            @dummy.should_not_include "mm"
           end
         end
 
         def test_should_not_include_shouldnt_raise_when_array_inclusion_is_missing
           assert_nothing_raised do
-            [1, 2, 3].should.not.include 5
+            [1, 2, 3].should_not_include 5
           end
         end
 
         def test_should_not_include_should_raise_when_array_inclusion_is_present
           assert_raise(ExpectationNotMetError) do
-            [1, 2, 3].should.not.include 2
+            [1, 2, 3].should_not_include 2
           end
         end
 
         def test_should_not_include_shouldnt_raise_when_hash_inclusion_is_missing
           assert_nothing_raised do
-            {"a"=>1}.should.not.include "b"
+            {"a"=>1}.should_not_include "b"
           end
         end
 
         def test_should_not_include_should_raise_when_hash_inclusion_is_present
           assert_raise(ExpectationNotMetError) do
-            {"a"=>1}.should.not.include "a"
+            {"a"=>1}.should_not_include "a"
           end
         end
 
         def test_should_not_include_shouldnt_raise_when_enumerable_inclusion_is_present
           assert_nothing_raised do
-            IO.constants.should.not.include "BLAH"
+            IO.constants.should_not_include "BLAH"
           end
         end
 
         def test_should_not_include_should_raise_when_enumerable_inclusion_is_missing
           assert_raise(ExpectationNotMetError) do
-            IO.constants.should.not.include "SEEK_SET" 
+            IO.constants.should_not_include "SEEK_SET" 
           end
         end
       end

data/test/spec/api/helper/identity_test.rb

@@ -14,25 +14,25 @@ module Spec
 
         def test_should_not_raise_when_objects_are_same
           assert_nothing_raised do
-            @dummy.should.be @dummy
+            @dummy.should_be @dummy
           end
         end
 
         def test_should_raise_when_objects_are_not_same
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.be @equal_dummy
+            @dummy.should_be @equal_dummy
           end
         end
 
         def test_should_not_raise_when_both_objects_are_nil
           assert_nothing_raised do
-            @nil_var.should.be nil
+            @nil_var.should_be nil
           end  
         end
 
         def test_should_raise_when_object_is_not_nil
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.be nil
+            @dummy.should_be nil
           end
         end
       end
@@ -47,25 +47,25 @@ module Spec
 
         def test_should_not_raise_when_objects_are_not_same
           assert_nothing_raised do
-            @dummy.should.not.be @equal_dummy
+            @dummy.should_not_be @equal_dummy
           end
         end
 
         def test_should_raise_when_objects_are_same
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.not.be @dummy
+            @dummy.should_not_be @dummy
           end
         end
 
         def test_should_not_raise_when_left_is_not_nil_and_right_is_nil
           assert_nothing_raised do
-            @dummy.should.not.be nil
+            @dummy.should_not_be nil
           end  
         end
 
         def test_should_raise_when_both_objects_are_nil
           assert_raise(ExpectationNotMetError) do
-            @nil_var.should.not.be nil
+            @nil_var.should_not_be nil
           end
         end
 

data/test/spec/api/helper/object_equality_test.rb

@@ -7,13 +7,13 @@ module Spec
 
         def test_should_not_raise_when_objects_are_equal
           assert_nothing_raised do
-            'apple'.should.equal 'apple'
+            'apple'.should_equal 'apple'
           end
         end
   
         def test_should_raise_when_objects_are_not_equal
           assert_raise(ExpectationNotMetError) do
-            'apple'.should.equal 'orange'
+            'apple'.should_equal 'orange'
           end
         end        
       end
@@ -22,13 +22,13 @@ module Spec
 
         def test_should_not_raise_when_objects_are_not_equal
           assert_nothing_raised do
-            'apple'.should.not.equal 'orange'
+            'apple'.should_not_equal 'orange'
           end
         end
 
         def test_should_not_equal_should_raise_when_objects_are_equal
           assert_raise(ExpectationNotMetError) do
-            'apple'.should.not.equal 'apple'
+            'apple'.should_not_equal 'apple'
           end
         end
       end
@@ -36,26 +36,26 @@ module Spec
       class ShouldBeCloseTest < Test::Unit::TestCase
         def test_should_not_raise_when_values_are_within_bounds
           assert_nothing_raised do
-            3.5.should.be.close 3.5, 0.5
-            3.5.should.be.close 3.1, 0.5
-            3.5.should.be.close 3.01, 0.5
-            3.5.should.be.close 3.9, 0.5
-            3.5.should.be.close 3.99, 0.5
+            3.5.should_be_close 3.5, 0.5
+            3.5.should_be_close 3.1, 0.5
+            3.5.should_be_close 3.01, 0.5
+            3.5.should_be_close 3.9, 0.5
+            3.5.should_be_close 3.99, 0.5
           end
         end
         
         def test_should_raise_when_values_are_outside_bounds
           assert_raise(ExpectationNotMetError) do
-            3.5.should.be.close 3.0, 0.5
+            3.5.should_be_close 3.0, 0.5
           end
           assert_raise(ExpectationNotMetError) do
-            3.5.should.be.close 2.0, 0.5
+            3.5.should_be_close 2.0, 0.5
           end
           assert_raise(ExpectationNotMetError) do
-            3.5.should.be.close 4.0, 0.5
+            3.5.should_be_close 4.0, 0.5
           end
           assert_raise(ExpectationNotMetError) do
-            3.5.should.be.close 5.0, 0.5
+            3.5.should_be_close 5.0, 0.5
           end
         end
 

data/test/spec/api/helper/raising_test.rb

@@ -7,31 +7,31 @@ module Spec
 
         def test_should_pass_when_exact_exception_is_raised
           assert_nothing_raised do
-            proc { ''.nonexistent_method }.should.raise NoMethodError
+            proc { ''.nonexistent_method }.should_raise NoMethodError
           end
         end
   
         def test_should_pass_when_exact_exception_is_raised_with_message
           assert_nothing_raised do
-            lambda { raise StandardError.new("this is standard") }.should.raise StandardError, "this is standard"
+            lambda { raise StandardError.new("this is standard") }.should_raise StandardError, "this is standard"
           end
         end
   
         def test_should_fail_when_exact_exception_is_raised_with_wrong_message
           assert_raises(Spec::Api::ExpectationNotMetError) do
-            lambda { raise StandardError.new("chunky bacon") }.should.raise StandardError, "rotten tomatoes"
+            lambda { raise StandardError.new("chunky bacon") }.should_raise StandardError, "rotten tomatoes"
           end
         end
   
         def test_should_pass_when_subclass_exception_is_raised
           assert_nothing_raised do
-            proc { ''.nonexistent_method }.should.raise
+            proc { ''.nonexistent_method }.should_raise
           end
         end
   
         def test_should_fail_when_wrong_exception_is_raised
           begin
-            proc { ''.nonexistent_method }.should.raise SyntaxError
+            proc { ''.nonexistent_method }.should_raise SyntaxError
           rescue => e
           end
           assert_equal("<Proc> should raise <SyntaxError> but raised #<NoMethodError: undefined method `nonexistent_method' for \"\":String>", e.message)
@@ -39,7 +39,7 @@ module Spec
   
         def test_should_fail_when_no_exception_is_raised
           begin
-            proc { }.should.raise SyntaxError
+            proc { }.should_raise SyntaxError
           rescue => e
           end
           assert_equal("<Proc> should raise <SyntaxError> but raised nothing", e.message)
@@ -50,37 +50,37 @@ module Spec
   
         def test_should_pass_when_exact_exception_is_raised_with_wrong_message
           assert_nothing_raised do
-            lambda { raise StandardError.new("abc") }.should.not.raise StandardError, "xyz"
+            lambda { raise StandardError.new("abc") }.should_not_raise StandardError, "xyz"
           end
         end
   
         def test_should_faile_when_exact_exception_is_raised_with_message
           assert_raises(Spec::Api::ExpectationNotMetError) do
-            lambda { raise StandardError.new("abc") }.should.not.raise StandardError, "abc"
+            lambda { raise StandardError.new("abc") }.should_not_raise StandardError, "abc"
           end
         end
   
         def test_should_pass_when_other_exception_is_raised
           assert_nothing_raised do
-            proc { ''.nonexistent_method }.should.not.raise SyntaxError
+            proc { ''.nonexistent_method }.should_not_raise SyntaxError
           end
         end
   
         def test_should_pass_when_no_exception_is_raised
           assert_nothing_raised do
-            proc { ''.to_s }.should.not.raise NoMethodError
+            proc { ''.to_s }.should_not_raise NoMethodError
           end
         end
 
         def test_without_exception_should_pass_when_no_exception_is_raised
           assert_nothing_raised do
-            proc { ''.to_s }.should.not.raise
+            proc { ''.to_s }.should_not_raise
           end
         end
         
         def test_should_fail_when_specific_exception_is_raised
           begin
-            proc { ''.nonexistent_method }.should.not.raise NoMethodError
+            proc { ''.nonexistent_method }.should_not_raise NoMethodError
           rescue => e
           end
           assert_equal("<Proc> should not raise <NoMethodError>", e.message)
@@ -88,7 +88,7 @@ module Spec
   
         def test_should_include_actual_error_in_failure_message
           begin
-            proc { ''.nonexistent_method }.should.not.raise Exception
+            proc { ''.nonexistent_method }.should_not_raise Exception
           rescue => e
           end
           assert_equal("<Proc> should not raise <Exception> but raised #<NoMethodError: undefined method `nonexistent_method' for \"\":String>", e.message)
@@ -97,7 +97,7 @@ module Spec
         def TODOtest_should_understand_raised_with_message_matching
           lambda do
             raise 'Hello'
-          end.should.raise(StandardError).with.message.matching /ello/
+          end.should_raise(StandardError).with.message.matching /ello/
         end
 
       end