Revert rspec-runner change. TODO: Add back support for the rspec T::U runner.

2 files changed, 306 insertions, 310 deletions

diff --git a/activesupport/lib/active_support/testing/setup_and_teardown.rb b/activesupport/lib/active_support/testing/setup_and_teardown.rb
index 780c1309f4..6248bf1921 100644
--- a/activesupport/lib/active_support/testing/setup_and_teardown.rb
+++ b/activesupport/lib/active_support/testing/setup_and_teardown.rb
@@ -10,6 +10,8 @@ module ActiveSupport
 
           if defined? MiniTest
             include ForMiniTest
+          elsif defined? Spec
+            include ForRspec
           else
             include ForClassicTestUnit
           end
@@ -34,19 +36,11 @@ module ActiveSupport
           result
         end
       end
-
+      
       module ForClassicTestUnit
         # For compatibility with Ruby < 1.8.6
         PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
 
-        def setup
-          run_callbacks :setup
-        end
-
-        def teardown
-          run_callbacks :teardown, :enumerator => :reverse_each
-        end
-
         # This redefinition is unfortunate but test/unit shows us no alternative.
         # Doubly unfortunate: hax to support Mocha's hax.
         def run(result)
@@ -60,7 +54,7 @@ module ActiveSupport
           @_result = result
           begin
             begin
-              # run_callbacks :setup
+              run_callbacks :setup
               setup
               __send__(@method_name)
               mocha_verify(assertion_counter) if using_mocha
@@ -74,7 +68,7 @@ module ActiveSupport
             ensure
               begin
                 teardown
-                # run_callbacks :teardown, :enumerator => :reverse_each
+                run_callbacks :teardown, :enumerator => :reverse_each
               rescue Test::Unit::AssertionFailedError => e
                 add_failure(e.message, e.backtrace)
               rescue Exception => e
diff --git a/activesupport/test/new_callbacks_test.rb b/activesupport/test/new_callbacks_test.rb
index 6948ad23dc..5cde078b65 100644
--- a/activesupport/test/new_callbacks_test.rb
+++ b/activesupport/test/new_callbacks_test.rb
@@ -3,380 +3,382 @@ require 'test/unit'
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'active_support'
 
-class Record
-  include ActiveSupport::NewCallbacks
+module NewCallbacksTest
+  class Record
+    include ActiveSupport::NewCallbacks
 
-  define_callbacks :save
+    define_callbacks :save
   
-  def self.before_save(*filters, &blk)
-    save_callback(:before, *filters, &blk)
-  end
+    def self.before_save(*filters, &blk)
+      save_callback(:before, *filters, &blk)
+    end
   
-  def self.after_save(*filters, &blk)
-    save_callback(:after, *filters, &blk)
-  end
+    def self.after_save(*filters, &blk)
+      save_callback(:after, *filters, &blk)
+    end
 
-  class << self
-    def callback_symbol(callback_method)
-      returning(:"#{callback_method}_method") do |method_name|
-        define_method(method_name) do
-          history << [callback_method, :symbol]
+    class << self
+      def callback_symbol(callback_method)
+        returning(:"#{callback_method}_method") do |method_name|
+          define_method(method_name) do
+            history << [callback_method, :symbol]
+          end
         end
       end
-    end
 
-    def callback_string(callback_method)
-      "history << [#{callback_method.to_sym.inspect}, :string]"
-    end
+      def callback_string(callback_method)
+        "history << [#{callback_method.to_sym.inspect}, :string]"
+      end
 
-    def callback_proc(callback_method)
-      Proc.new { |model| model.history << [callback_method, :proc] }
-    end
+      def callback_proc(callback_method)
+        Proc.new { |model| model.history << [callback_method, :proc] }
+      end
 
-    def callback_object(callback_method)
-      klass = Class.new
-      klass.send(:define_method, callback_method) do |model|
-        model.history << [callback_method, :object]
+      def callback_object(callback_method)
+        klass = Class.new
+        klass.send(:define_method, callback_method) do |model|
+          model.history << [callback_method, :object]
+        end
+        klass.new
       end
-      klass.new
     end
-  end
 
-  def history
-    @history ||= []
+    def history
+      @history ||= []
+    end
   end
-end
 
-class Person < Record
-  [:before_save, :after_save].each do |callback_method|
-    callback_method_sym = callback_method.to_sym
-    send(callback_method, callback_symbol(callback_method_sym))
-    send(callback_method, callback_string(callback_method_sym))
-    send(callback_method, callback_proc(callback_method_sym))
-    send(callback_method, callback_object(callback_method_sym))
-    send(callback_method) { |model| model.history << [callback_method_sym, :block] }
-  end
+  class Person < Record
+    [:before_save, :after_save].each do |callback_method|
+      callback_method_sym = callback_method.to_sym
+      send(callback_method, callback_symbol(callback_method_sym))
+      send(callback_method, callback_string(callback_method_sym))
+      send(callback_method, callback_proc(callback_method_sym))
+      send(callback_method, callback_object(callback_method_sym))
+      send(callback_method) { |model| model.history << [callback_method_sym, :block] }
+    end
 
-  def save
-    _run_save_callbacks {}
+    def save
+      _run_save_callbacks {}
+    end
   end
-end
 
-class PersonSkipper < Person
-  skip_save_callback :before, :before_save_method, :if => :yes
-  skip_save_callback :after, :before_save_method, :unless => :yes
-  skip_save_callback :after, :before_save_method, :if => :no
-  skip_save_callback :before, :before_save_method, :unless => :no
-  def yes; true; end
-  def no; false; end
-end
+  class PersonSkipper < Person
+    skip_save_callback :before, :before_save_method, :if => :yes
+    skip_save_callback :after, :before_save_method, :unless => :yes
+    skip_save_callback :after, :before_save_method, :if => :no
+    skip_save_callback :before, :before_save_method, :unless => :no
+    def yes; true; end
+    def no; false; end
+  end
 
-class ParentController
-  include ActiveSupport::NewCallbacks
+  class ParentController
+    include ActiveSupport::NewCallbacks
 
-  define_callbacks :dispatch
+    define_callbacks :dispatch
     
-  dispatch_callback :before, :log, :per_key => {:unless => proc {|c| c.action_name == :index || c.action_name == :show }}
-  dispatch_callback :after, :log2
+    dispatch_callback :before, :log, :per_key => {:unless => proc {|c| c.action_name == :index || c.action_name == :show }}
+    dispatch_callback :after, :log2
   
-  attr_reader :action_name, :logger
-  def initialize(action_name)
-    @action_name, @logger = action_name, []
-  end
+    attr_reader :action_name, :logger
+    def initialize(action_name)
+      @action_name, @logger = action_name, []
+    end
   
-  def log
-    @logger << action_name
-  end
+    def log
+      @logger << action_name
+    end
   
-  def log2
-    @logger << action_name
-  end
+    def log2
+      @logger << action_name
+    end
   
-  def dispatch
-    _run_dispatch_callbacks(action_name) {
-      @logger << "Done"
-    }
-    self
+    def dispatch
+      _run_dispatch_callbacks(action_name) {
+        @logger << "Done"
+      }
+      self
+    end
   end
-end
 
-class Child < ParentController
-  skip_dispatch_callback :before, :log, :per_key => {:if => proc {|c| c.action_name == :update} }
-  skip_dispatch_callback :after, :log2
-end
+  class Child < ParentController
+    skip_dispatch_callback :before, :log, :per_key => {:if => proc {|c| c.action_name == :update} }
+    skip_dispatch_callback :after, :log2
+  end
 
-class OneTimeCompile < Record
-  @@starts_true, @@starts_false = true, false
+  class OneTimeCompile < Record
+    @@starts_true, @@starts_false = true, false
   
-  def initialize
-    super
-  end
+    def initialize
+      super
+    end
   
-  before_save Proc.new {|r| r.history << [:before_save, :starts_true, :if] }, :per_key => {:if => :starts_true}
-  before_save Proc.new {|r| r.history << [:before_save, :starts_false, :if] }, :per_key => {:if => :starts_false}
-  before_save Proc.new {|r| r.history << [:before_save, :starts_true, :unless] }, :per_key => {:unless => :starts_true}
-  before_save Proc.new {|r| r.history << [:before_save, :starts_false, :unless] }, :per_key => {:unless => :starts_false}
+    before_save Proc.new {|r| r.history << [:before_save, :starts_true, :if] }, :per_key => {:if => :starts_true}
+    before_save Proc.new {|r| r.history << [:before_save, :starts_false, :if] }, :per_key => {:if => :starts_false}
+    before_save Proc.new {|r| r.history << [:before_save, :starts_true, :unless] }, :per_key => {:unless => :starts_true}
+    before_save Proc.new {|r| r.history << [:before_save, :starts_false, :unless] }, :per_key => {:unless => :starts_false}
   
-  def starts_true
-    if @@starts_true
-      @@starts_true = false
-      return true
+    def starts_true
+      if @@starts_true
+        @@starts_true = false
+        return true
+      end
+      @@starts_true
     end
-    @@starts_true
-  end
   
-  def starts_false
-    unless @@starts_false
-      @@starts_false = true
-      return false
+    def starts_false
+      unless @@starts_false
+        @@starts_false = true
+        return false
+      end
+      @@starts_false
     end
-    @@starts_false
-  end
   
-  def save
-    _run_save_callbacks(:action) {}
+    def save
+      _run_save_callbacks(:action) {}
+    end
   end
-end
 
-class OneTimeCompileTest < Test::Unit::TestCase
-  def test_optimized_first_compile
-    around = OneTimeCompile.new
-    around.save
-    assert_equal [
-      [:before_save, :starts_true, :if],
-      [:before_save, :starts_true, :unless]
-    ], around.history
+  class OneTimeCompileTest < Test::Unit::TestCase
+    def test_optimized_first_compile
+      around = OneTimeCompile.new
+      around.save
+      assert_equal [
+        [:before_save, :starts_true, :if],
+        [:before_save, :starts_true, :unless]
+      ], around.history
+    end
   end
-end
 
-class ConditionalPerson < Record
-  # proc
-  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true }
-  before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false }
-  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false }
-  before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true }
-  # symbol
-  before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :if => :yes
-  before_save Proc.new { |r| r.history << "b00m" }, :if => :no
-  before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :unless => :no
-  before_save Proc.new { |r| r.history << "b00m" }, :unless => :yes
-  # string
-  before_save Proc.new { |r| r.history << [:before_save, :string] }, :if => 'yes'
-  before_save Proc.new { |r| r.history << "b00m" }, :if => 'no'
-  before_save Proc.new { |r| r.history << [:before_save, :string] }, :unless => 'no'
-  before_save Proc.new { |r| r.history << "b00m" }, :unless => 'yes'
-  # Combined if and unless
-  before_save Proc.new { |r| r.history << [:before_save, :combined_symbol] }, :if => :yes, :unless => :no
-  before_save Proc.new { |r| r.history << "b00m" }, :if => :yes, :unless => :yes
+  class ConditionalPerson < Record
+    # proc
+    before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true }
+    before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false }
+    before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false }
+    before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true }
+    # symbol
+    before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :if => :yes
+    before_save Proc.new { |r| r.history << "b00m" }, :if => :no
+    before_save Proc.new { |r| r.history << [:before_save, :symbol] }, :unless => :no
+    before_save Proc.new { |r| r.history << "b00m" }, :unless => :yes
+    # string
+    before_save Proc.new { |r| r.history << [:before_save, :string] }, :if => 'yes'
+    before_save Proc.new { |r| r.history << "b00m" }, :if => 'no'
+    before_save Proc.new { |r| r.history << [:before_save, :string] }, :unless => 'no'
+    before_save Proc.new { |r| r.history << "b00m" }, :unless => 'yes'
+    # Combined if and unless
+    before_save Proc.new { |r| r.history << [:before_save, :combined_symbol] }, :if => :yes, :unless => :no
+    before_save Proc.new { |r| r.history << "b00m" }, :if => :yes, :unless => :yes
 
-  def yes; true; end
-  def other_yes; true; end
-  def no; false; end
-  def other_no; false; end
+    def yes; true; end
+    def other_yes; true; end
+    def no; false; end
+    def other_no; false; end
 
-  def save
-    _run_save_callbacks {}
+    def save
+      _run_save_callbacks {}
+    end
   end
-end
 
-class MySuper
-  include ActiveSupport::NewCallbacks
-  define_callbacks :save
-end
+  class MySuper
+    include ActiveSupport::NewCallbacks
+    define_callbacks :save
+  end
 
-class AroundPerson < MySuper
-  attr_reader :history
+  class AroundPerson < MySuper
+    attr_reader :history
   
-  save_callback :before, :nope,           :if =>     :no
-  save_callback :before, :nope,           :unless => :yes
-  save_callback :after,  :tweedle
-  save_callback :before, "tweedle_dee"
-  save_callback :before, proc {|m| m.history << "yup" }
-  save_callback :before, :nope,           :if =>     proc { false }
-  save_callback :before, :nope,           :unless => proc { true }
-  save_callback :before, :yup,            :if =>     proc { true }
-  save_callback :before, :yup,            :unless => proc { false }
-  save_callback :around, :tweedle_dum
-  save_callback :around, :w0tyes,         :if =>     :yes
-  save_callback :around, :w0tno,          :if =>     :no
-  save_callback :around, :tweedle_deedle
+    save_callback :before, :nope,           :if =>     :no
+    save_callback :before, :nope,           :unless => :yes
+    save_callback :after,  :tweedle
+    save_callback :before, "tweedle_dee"
+    save_callback :before, proc {|m| m.history << "yup" }
+    save_callback :before, :nope,           :if =>     proc { false }
+    save_callback :before, :nope,           :unless => proc { true }
+    save_callback :before, :yup,            :if =>     proc { true }
+    save_callback :before, :yup,            :unless => proc { false }
+    save_callback :around, :tweedle_dum
+    save_callback :around, :w0tyes,         :if =>     :yes
+    save_callback :around, :w0tno,          :if =>     :no
+    save_callback :around, :tweedle_deedle
   
-  def no; false; end
-  def yes; true; end
+    def no; false; end
+    def yes; true; end
   
-  def nope
-    @history << "boom"
-  end
+    def nope
+      @history << "boom"
+    end
   
-  def yup
-    @history << "yup"
-  end
+    def yup
+      @history << "yup"
+    end
   
-  def w0tyes
-    @history << "w0tyes before"
-    yield
-    @history << "w0tyes after"
-  end
+    def w0tyes
+      @history << "w0tyes before"
+      yield
+      @history << "w0tyes after"
+    end
   
-  def w0tno
-    @history << "boom"
-    yield
-  end
+    def w0tno
+      @history << "boom"
+      yield
+    end
   
-  def tweedle_dee
-    @history << "tweedle dee"
-  end
+    def tweedle_dee
+      @history << "tweedle dee"
+    end
   
-  def tweedle_dum
-    @history << "tweedle dum pre"
-    yield
-    @history << "tweedle dum post"
-  end
+    def tweedle_dum
+      @history << "tweedle dum pre"
+      yield
+      @history << "tweedle dum post"
+    end
   
-  def tweedle
-    @history << "tweedle"
-  end
+    def tweedle
+      @history << "tweedle"
+    end
   
-  def tweedle_deedle
-    @history << "tweedle deedle pre"
-    yield
-    @history << "tweedle deedle post"
-  end
+    def tweedle_deedle
+      @history << "tweedle deedle pre"
+      yield
+      @history << "tweedle deedle post"
+    end
   
-  def initialize
-    @history = []
-  end
+    def initialize
+      @history = []
+    end
   
-  def save
-    _run_save_callbacks do
-      @history << "running"
+    def save
+      _run_save_callbacks do
+        @history << "running"
+      end
     end
   end
-end
 
-class AroundCallbacksTest < Test::Unit::TestCase
-  def test_save_around
-    around = AroundPerson.new
-    around.save
-    assert_equal [
-      "tweedle dee",
-      "yup", "yup", "yup",
-      "tweedle dum pre",
-      "w0tyes before",
-      "tweedle deedle pre",
-      "running",
-      "tweedle deedle post",
-      "w0tyes after",
-      "tweedle dum post",
-      "tweedle"
-    ], around.history
+  class AroundCallbacksTest < Test::Unit::TestCase
+    def test_save_around
+      around = AroundPerson.new
+      around.save
+      assert_equal [
+        "tweedle dee",
+        "yup", "yup",
+        "tweedle dum pre",
+        "w0tyes before",
+        "tweedle deedle pre",
+        "running",
+        "tweedle deedle post",
+        "w0tyes after",
+        "tweedle dum post",
+        "tweedle"
+      ], around.history
+    end
   end
-end
 
-class SkipCallbacksTest < Test::Unit::TestCase
-  def test_skip_person
-    person = PersonSkipper.new
-    assert_equal [], person.history
-    person.save
-    assert_equal [
-      [:before_save, :string],
-      [:before_save, :proc],
-      [:before_save, :object],
-      [:before_save, :block],
-      [:after_save, :block],
-      [:after_save, :object],
-      [:after_save, :proc],
-      [:after_save, :string],
-      [:after_save, :symbol]
-    ], person.history
+  class SkipCallbacksTest < Test::Unit::TestCase
+    def test_skip_person
+      person = PersonSkipper.new
+      assert_equal [], person.history
+      person.save
+      assert_equal [
+        [:before_save, :string],
+        [:before_save, :proc],
+        [:before_save, :object],
+        [:before_save, :block],
+        [:after_save, :block],
+        [:after_save, :object],
+        [:after_save, :proc],
+        [:after_save, :string],
+        [:after_save, :symbol]
+      ], person.history
+    end
   end
-end
 
-class CallbacksTest < Test::Unit::TestCase
-  def test_save_person
-    person = Person.new
-    assert_equal [], person.history
-    person.save
-    assert_equal [
-      [:before_save, :symbol],
-      [:before_save, :string],
-      [:before_save, :proc],
-      [:before_save, :object],
-      [:before_save, :block],
-      [:after_save, :block],
-      [:after_save, :object],
-      [:after_save, :proc],
-      [:after_save, :string],
-      [:after_save, :symbol]
-    ], person.history
+  class CallbacksTest < Test::Unit::TestCase
+    def test_save_person
+      person = Person.new
+      assert_equal [], person.history
+      person.save
+      assert_equal [
+        [:before_save, :symbol],
+        [:before_save, :string],
+        [:before_save, :proc],
+        [:before_save, :object],
+        [:before_save, :block],
+        [:after_save, :block],
+        [:after_save, :object],
+        [:after_save, :proc],
+        [:after_save, :string],
+        [:after_save, :symbol]
+      ], person.history
+    end
   end
-end
 
-class ConditionalCallbackTest < Test::Unit::TestCase
-  def test_save_conditional_person
-    person = ConditionalPerson.new
-    person.save
-    assert_equal [
-      [:before_save, :proc],
-      [:before_save, :proc],
-      [:before_save, :symbol],
-      [:before_save, :symbol],
-      [:before_save, :string],
-      [:before_save, :string],
-      [:before_save, :combined_symbol],
-    ], person.history
+  class ConditionalCallbackTest < Test::Unit::TestCase
+    def test_save_conditional_person
+      person = ConditionalPerson.new
+      person.save
+      assert_equal [
+        [:before_save, :proc],
+        [:before_save, :proc],
+        [:before_save, :symbol],
+        [:before_save, :symbol],
+        [:before_save, :string],
+        [:before_save, :string],
+        [:before_save, :combined_symbol],
+      ], person.history
+    end
   end
-end
 
-class CallbackTerminator
-  include ActiveSupport::NewCallbacks
+  class CallbackTerminator
+    include ActiveSupport::NewCallbacks
   
-  define_callbacks :save, "result == :halt"
+    define_callbacks :save, "result == :halt"
   
-  save_callback :before, :first
-  save_callback :before, :second
-  save_callback :around, :around_it  
-  save_callback :before, :third
-  save_callback :after, :first
-  save_callback :around, :around_it
-  save_callback :after, :second
-  save_callback :around, :around_it
-  save_callback :after, :third
+    save_callback :before, :first
+    save_callback :before, :second
+    save_callback :around, :around_it  
+    save_callback :before, :third
+    save_callback :after, :first
+    save_callback :around, :around_it
+    save_callback :after, :second
+    save_callback :around, :around_it
+    save_callback :after, :third
 
   
-  attr_reader :history
-  def initialize
-    @history = []
-  end
+    attr_reader :history
+    def initialize
+      @history = []
+    end
   
-  def around_it
-    @history << "around1"
-    yield
-    @history << "around2"
-  end
+    def around_it
+      @history << "around1"
+      yield
+      @history << "around2"
+    end
   
-  def first
-    @history << "first"
-  end
+    def first
+      @history << "first"
+    end
   
-  def second
-    @history << "second"
-    :halt
-  end
+    def second
+      @history << "second"
+      :halt
+    end
   
-  def third
-    @history << "third"
-  end
+    def third
+      @history << "third"
+    end
   
-  def save
-    _run_save_callbacks
+    def save
+      _run_save_callbacks
+    end
   end
-end
 
-class CallbackTerminatorTest < Test::Unit::TestCase
-  def test_termination
-    terminator = CallbackTerminator.new
-    terminator.save
-    assert_equal ["first", "second", "third", "second", "first"], terminator.history
+  class CallbackTerminatorTest < Test::Unit::TestCase
+    def test_termination
+      terminator = CallbackTerminator.new
+      terminator.save
+      assert_equal ["first", "second", "third", "second", "first"], terminator.history
+    end
   end
-end
+end
\ No newline at end of file