Merge remote branch 'rails/master' into identity_map

Conflicts:
	activerecord/examples/performance.rb
	activerecord/lib/active_record/association_preload.rb
	activerecord/lib/active_record/associations.rb
	activerecord/lib/active_record/associations/association_proxy.rb
	activerecord/lib/active_record/autosave_association.rb
	activerecord/lib/active_record/base.rb
	activerecord/lib/active_record/nested_attributes.rb
	activerecord/test/cases/relations_test.rb

20 files changed, 373 insertions, 94 deletions

diff --git a/activesupport/test/callback_inheritance_test.rb b/activesupport/test/callback_inheritance_test.rb
index 8caf000c5d..71249050fc 100644
--- a/activesupport/test/callback_inheritance_test.rb
+++ b/activesupport/test/callback_inheritance_test.rb
@@ -70,7 +70,7 @@ class EmptyParent
   end
 
   def dispatch
-    _run_dispatch_callbacks
+    run_callbacks :dispatch
     self
   end
 end
diff --git a/activesupport/test/callbacks_test.rb b/activesupport/test/callbacks_test.rb
index 51b28b6a43..cff914f4ae 100644
--- a/activesupport/test/callbacks_test.rb
+++ b/activesupport/test/callbacks_test.rb
@@ -3,6 +3,27 @@ require 'test/unit'
 require 'active_support'
 
 module CallbacksTest
+  class Phone
+    include ActiveSupport::Callbacks
+    define_callbacks :save, :rescuable => true
+
+    set_callback :save, :before, :before_save1
+    set_callback :save, :after, :after_save1
+
+    def before_save1; self.history << :before; end
+    def after_save1; self.history << :after; end
+
+    def save
+      run_callbacks :save do
+        raise 'boom'
+      end
+    end
+
+    def history
+      @history ||= []
+    end
+  end
+
   class Record
     include ActiveSupport::Callbacks
 
@@ -338,6 +359,14 @@ module CallbacksTest
   end
 
   class CallbacksTest < Test::Unit::TestCase
+    def test_save_phone
+      phone = Phone.new
+      assert_raise RuntimeError do
+        phone.save
+      end
+      assert_equal [:before, :after], phone.history
+    end
+
     def test_save_person
       person = Person.new
       assert_equal [], person.history
@@ -573,5 +602,5 @@ module CallbacksTest
       ], writer.history
     end
   end
-  
+
 end
diff --git a/activesupport/test/core_ext/bigdecimal.rb b/activesupport/test/core_ext/bigdecimal.rb
deleted file mode 100644
index 9faad9146f..0000000000
--- a/activesupport/test/core_ext/bigdecimal.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'abstract_unit'
-
-class BigDecimalTest < Test::Unit::TestCase
-  def test_to_yaml
-    assert_equal("--- 100000.30020320320000000000000000000000000000001\n", BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml)
-    assert_equal("--- .Inf\n", BigDecimal.new('Infinity').to_yaml)
-    assert_equal("--- .NaN\n", BigDecimal.new('NaN').to_yaml)
-    assert_equal("--- -.Inf\n", BigDecimal.new('-Infinity').to_yaml)
-  end
-end
\ No newline at end of file
diff --git a/activesupport/test/core_ext/bigdecimal_test.rb b/activesupport/test/core_ext/bigdecimal_test.rb
new file mode 100644
index 0000000000..b38e08a9f4
--- /dev/null
+++ b/activesupport/test/core_ext/bigdecimal_test.rb
@@ -0,0 +1,17 @@
+require 'abstract_unit'
+require 'bigdecimal'
+require 'active_support/core_ext/big_decimal'
+
+class BigDecimalTest < Test::Unit::TestCase
+  def test_to_yaml
+    assert_match("--- 100000.30020320320000000000000000000000000000001\n", BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml)
+    assert_match("--- .Inf\n",  BigDecimal.new('Infinity').to_yaml)
+    assert_match("--- .NaN\n",  BigDecimal.new('NaN').to_yaml)
+    assert_match("--- -.Inf\n", BigDecimal.new('-Infinity').to_yaml)
+  end
+
+  def test_to_d
+    bd = BigDecimal.new '10'
+    assert_equal bd, bd.to_d
+  end
+end
diff --git a/activesupport/test/core_ext/date_ext_test.rb b/activesupport/test/core_ext/date_ext_test.rb
index 342a31cdef..b4d7633e5f 100644
--- a/activesupport/test/core_ext/date_ext_test.rb
+++ b/activesupport/test/core_ext/date_ext_test.rb
@@ -376,6 +376,16 @@ class DateExtCalculationsTest < ActiveSupport::TestCase
     end
   end
 
+  if RUBY_VERSION < '1.9'
+    def test_rfc3339
+      assert_equal('1980-02-28', Date.new(1980, 2, 28).rfc3339)
+    end
+
+    def test_iso8601
+      assert_equal('1980-02-28', Date.new(1980, 2, 28).iso8601)
+    end
+  end
+
   def test_today
     Date.stubs(:current).returns(Date.new(2000, 1, 1))
     assert_equal false, Date.new(1999, 12, 31).today?
diff --git a/activesupport/test/core_ext/date_time_ext_test.rb b/activesupport/test/core_ext/date_time_ext_test.rb
index 7d993d84e2..8edb95b63a 100644
--- a/activesupport/test/core_ext/date_time_ext_test.rb
+++ b/activesupport/test/core_ext/date_time_ext_test.rb
@@ -38,6 +38,8 @@ class DateTimeExtCalculationsTest < Test::Unit::TestCase
     assert_equal Time.utc_time(2039, 2, 21, 10, 11, 12), DateTime.new(2039, 2, 21, 10, 11, 12, 0, 0).to_time
     # DateTimes with offsets other than 0 are returned unaltered
     assert_equal DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)), DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)).to_time
+    # Fractional seconds are preserved
+    assert_equal Time.utc(2005, 2, 21, 10, 11, 12, 256), DateTime.new(2005, 2, 21, 10, 11, 12 + Rational(256, 1000000), 0).to_time
   end
 
   def test_civil_from_format
diff --git a/activesupport/test/core_ext/duration_test.rb b/activesupport/test/core_ext/duration_test.rb
index bb453b8d7f..6a01eeed6b 100644
--- a/activesupport/test/core_ext/duration_test.rb
+++ b/activesupport/test/core_ext/duration_test.rb
@@ -1,5 +1,6 @@
 require 'abstract_unit'
 require 'active_support/time'
+require 'active_support/json'
 
 class DurationTest < ActiveSupport::TestCase
   def test_is_a
@@ -138,6 +139,10 @@ class DurationTest < ActiveSupport::TestCase
     assert_equal counter, 60
   end
 
+  def test_to_json
+    assert_equal '172800', 2.days.to_json
+  end
+
   protected
     def with_env_tz(new_tz = 'US/Eastern')
       old_tz, ENV['TZ'] = ENV['TZ'], new_tz
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 74223dd7f2..a0479d45ac 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -4,6 +4,7 @@ require 'bigdecimal'
 require 'active_support/core_ext/string/access'
 require 'active_support/ordered_hash'
 require 'active_support/core_ext/object/conversions'
+require 'active_support/inflections'
 
 class HashExtTest < Test::Unit::TestCase
   class IndifferentHash < HashWithIndifferentAccess
diff --git a/activesupport/test/core_ext/object_and_class_ext_test.rb b/activesupport/test/core_ext/object_and_class_ext_test.rb
index 398e6ca9b2..5d68b198f2 100644
--- a/activesupport/test/core_ext/object_and_class_ext_test.rb
+++ b/activesupport/test/core_ext/object_and_class_ext_test.rb
@@ -28,18 +28,6 @@ module Nested
   end
 end
 
-module Bar
-  def bar; end
-end
-
-module Baz
-  def baz; end
-end
-
-class Foo
-  include Bar
-end
-
 class ObjectTests < ActiveSupport::TestCase
   class DuckTime
     def acts_like_time?
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index 53d497013a..891a6badac 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -533,19 +533,9 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
     Time::DATE_FORMATS.delete(:custom)
   end
 
-  def test_to_date
-    assert_equal Date.new(2005, 2, 21), Time.local(2005, 2, 21, 17, 44, 30).to_date
-  end
-
-  def test_to_datetime
-    assert_equal Time.utc(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, 0, 0)
-    with_env_tz 'US/Eastern' do
-      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400), 0)
-    end
-    with_env_tz 'NZ' do
-      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400), 0)
-    end
-    assert_equal ::Date::ITALY, Time.utc(2005, 2, 21, 17, 44, 30).to_datetime.start # use Ruby's default start value
+  def test_conversion_methods_are_publicized
+    assert Time.public_instance_methods.include?(:to_date)     || Time.public_instance_methods.include?('to_date')
+    assert Time.public_instance_methods.include?(:to_datetime) || Time.public_instance_methods.include?('to_datetime')
   end
 
   def test_to_time
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 5579c27215..5c226c2d09 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -106,11 +106,11 @@ class TimeWithZoneTest < Test::Unit::TestCase
   end
 
   def test_to_yaml
-    assert_equal "--- 1999-12-31 19:00:00 -05:00\n", @twz.to_yaml
+    assert_match(/^--- 2000-01-01 00:00:00(\.0+)?\s*Z\n/, @twz.to_yaml)
   end
 
   def test_ruby_to_yaml
-    assert_equal "--- \n:twz: 2000-01-01 00:00:00 Z\n", {:twz => @twz}.to_yaml
+    assert_match(/---\s*\n:twz: 2000-01-01 00:00:00(\.0+)?\s*Z\n/, {:twz => @twz}.to_yaml)
   end
 
   def test_httpdate
diff --git a/activesupport/test/file_watcher_test.rb b/activesupport/test/file_watcher_test.rb
new file mode 100644
index 0000000000..3e577df5af
--- /dev/null
+++ b/activesupport/test/file_watcher_test.rb
@@ -0,0 +1,75 @@
+require 'abstract_unit'
+
+class FileWatcherTest < ActiveSupport::TestCase
+  class DumbBackend < ActiveSupport::FileWatcher::Backend
+  end
+
+  def setup
+    @watcher = ActiveSupport::FileWatcher.new
+
+    # In real life, the backend would take the path and use it to observe the file
+    # system. In our case, we will manually trigger the events for unit testing,
+    # so we can pass any path.
+    @backend = DumbBackend.new("RAILS_WOOT", @watcher)
+
+    @payload = []
+    @watcher.watch %r{^app/assets/.*\.scss$} do |pay|
+      pay.each do |status, files|
+        files.sort!
+      end
+      @payload << pay
+    end
+  end
+
+  def test_use_triple_equals
+    fw = ActiveSupport::FileWatcher.new
+    called = []
+    fw.watch("some_arbitrary_file.rb") do |file|
+      called << "omg"
+    end
+    fw.trigger(%w{ some_arbitrary_file.rb })
+    assert_equal ['omg'], called
+  end
+
+  def test_one_change
+    @backend.trigger("app/assets/main.scss" => :changed)
+    assert_equal({:changed => ["app/assets/main.scss"]}, @payload.first)
+  end
+
+  def test_multiple_changes
+    @backend.trigger("app/assets/main.scss" => :changed, "app/assets/javascripts/foo.coffee" => :changed)
+    assert_equal([{:changed => ["app/assets/main.scss"]}], @payload)
+  end
+
+  def test_multiple_changes_match
+    @backend.trigger("app/assets/main.scss" => :changed, "app/assets/print.scss" => :changed, "app/assets/javascripts/foo.coffee" => :changed)
+    assert_equal([{:changed => ["app/assets/main.scss", "app/assets/print.scss"]}], @payload)
+  end
+
+  def test_multiple_state_changes
+    @backend.trigger("app/assets/main.scss" => :created, "app/assets/print.scss" => :changed)
+    assert_equal([{:changed => ["app/assets/print.scss"], :created => ["app/assets/main.scss"]}], @payload)
+  end
+
+  def test_more_blocks
+    payload = []
+    @watcher.watch %r{^config/routes\.rb$} do |pay|
+      payload << pay
+    end
+
+    @backend.trigger "config/routes.rb" => :changed
+    assert_equal [:changed => ["config/routes.rb"]], payload
+    assert_equal [], @payload
+  end
+
+  def test_overlapping_watchers
+    payload = []
+    @watcher.watch %r{^app/assets/main\.scss$} do |pay|
+      payload << pay
+    end
+
+    @backend.trigger "app/assets/print.scss" => :changed, "app/assets/main.scss" => :changed
+    assert_equal [:changed => ["app/assets/main.scss"]], payload
+    assert_equal [:changed => ["app/assets/main.scss", "app/assets/print.scss"]], @payload
+  end
+end
diff --git a/activesupport/test/gzip_test.rb b/activesupport/test/gzip_test.rb
index 2a24c0bd0d..f564e63f29 100644
--- a/activesupport/test/gzip_test.rb
+++ b/activesupport/test/gzip_test.rb
@@ -1,7 +1,18 @@
 require 'abstract_unit'
+require 'active_support/core_ext/object/blank'
 
 class GzipTest < Test::Unit::TestCase
   def test_compress_should_decompress_to_the_same_value
     assert_equal "Hello World", ActiveSupport::Gzip.decompress(ActiveSupport::Gzip.compress("Hello World"))
   end
-end
\ No newline at end of file
+
+  def test_compress_should_return_a_binary_string
+    compressed = ActiveSupport::Gzip.compress('')
+
+    if "".encoding_aware?
+      assert_equal Encoding.find('binary'), compressed.encoding
+    end
+
+    assert !compressed.blank?, "a compressed blank string should not be blank"
+  end
+end
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 2990177bed..60714a152d 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -22,6 +22,34 @@ class InflectorTest < Test::Unit::TestCase
     assert_equal "", ActiveSupport::Inflector.pluralize("")
   end
 
+  ActiveSupport::Inflector.inflections.uncountable.each do |word|
+    define_method "test_uncountability_of_#{word}" do
+      assert_equal word, ActiveSupport::Inflector.singularize(word)
+      assert_equal word, ActiveSupport::Inflector.pluralize(word)
+      assert_equal ActiveSupport::Inflector.pluralize(word), ActiveSupport::Inflector.singularize(word)
+    end
+  end
+
+  def test_uncountable_word_is_not_greedy
+    uncountable_word = "ors"
+    countable_word = "sponsor"
+
+    cached_uncountables = ActiveSupport::Inflector.inflections.uncountables
+
+    ActiveSupport::Inflector.inflections.uncountable << uncountable_word
+
+    assert_equal uncountable_word, ActiveSupport::Inflector.singularize(uncountable_word)
+    assert_equal uncountable_word, ActiveSupport::Inflector.pluralize(uncountable_word)
+    assert_equal ActiveSupport::Inflector.pluralize(uncountable_word), ActiveSupport::Inflector.singularize(uncountable_word)
+
+    assert_equal "sponsor", ActiveSupport::Inflector.singularize(countable_word)
+    assert_equal "sponsors", ActiveSupport::Inflector.pluralize(countable_word)
+    assert_equal "sponsor", ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.pluralize(countable_word))
+
+  ensure
+    ActiveSupport::Inflector.inflections.instance_variable_set :@uncountables, cached_uncountables
+  end
+
   SingularToPlural.each do |singular, plural|
     define_method "test_pluralize_#{singular}" do
       assert_equal(plural, ActiveSupport::Inflector.pluralize(singular))
diff --git a/activesupport/test/json/decoding_test.rb b/activesupport/test/json/decoding_test.rb
index d2e3efaa6b..24d9f88c09 100644
--- a/activesupport/test/json/decoding_test.rb
+++ b/activesupport/test/json/decoding_test.rb
@@ -19,6 +19,12 @@ class TestJSONDecoding < ActiveSupport::TestCase
     %({"a": "2007-01-01 01:12:34 Z"})            => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
     # no time zone
     %({"a": "2007-01-01 01:12:34"})              => {'a' => "2007-01-01 01:12:34"},
+    # invalid date
+    %({"a": "1089-10-40"})                       => {'a' => "1089-10-40"},
+    # xmlschema date notation
+    %({"a": "2009-08-10T19:01:02Z"})             => {'a' => Time.utc(2009, 8, 10, 19, 1, 2)},
+    %({"a": "2009-08-10T19:01:02+02:00"})        => {'a' => Time.utc(2009, 8, 10, 17, 1, 2)},
+    %({"a": "2009-08-10T19:01:02-05:00"})        => {'a' => Time.utc(2009, 8, 11, 00, 1, 2)},
     # needs to be *exact*
     %({"a": " 2007-01-01 01:12:34 Z "})          => {'a' => " 2007-01-01 01:12:34 Z "},
     %({"a": "2007-01-01 : it's your birthday"})  => {'a' => "2007-01-01 : it's your birthday"},
@@ -41,7 +47,11 @@ class TestJSONDecoding < ActiveSupport::TestCase
       [{'d' => Date.new(1970, 1, 1), 's' => ' escape'},{'d' => Date.new(1970, 1, 1), 's' => ' escape'}],
     %q([{"d":"1970-01-01","s":"http:\/\/example.com"},{"d":"1970-01-01","s":"http:\/\/example.com"}]) =>
       [{'d' => Date.new(1970, 1, 1), 's' => 'http://example.com'},
-       {'d' => Date.new(1970, 1, 1), 's' => 'http://example.com'}]
+       {'d' => Date.new(1970, 1, 1), 's' => 'http://example.com'}],
+    # tests escaping of "\n" char with Yaml backend
+    %q({"a":"\n"})  => {"a"=>"\n"},
+    %q({"a":"\u000a"}) => {"a"=>"\n"},
+    %q({"a":"Line1\u000aLine2"}) => {"a"=>"Line1\nLine2"}
   }
 
   # load the default JSON backend
@@ -57,9 +67,7 @@ class TestJSONDecoding < ActiveSupport::TestCase
         ActiveSupport.parse_json_times = true
         silence_warnings do
           ActiveSupport::JSON.with_backend backend do
-            assert_nothing_raised do
-              assert_equal expected, ActiveSupport::JSON.decode(json)
-            end
+            assert_equal expected, ActiveSupport::JSON.decode(json)
           end
         end
       end
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index e0494de6e4..d5fcbf15b7 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -1,5 +1,6 @@
 # encoding: utf-8
 require 'abstract_unit'
+require 'active_support/core_ext/string/inflections'
 require 'active_support/json'
 
 class TestJSONEncoding < Test::Unit::TestCase
@@ -214,6 +215,36 @@ class TestJSONEncoding < Test::Unit::TestCase
     assert_equal(%([{"address":{"city":"London"}},{"address":{"city":"Paris"}}]), json)
   end
 
+  def test_struct_encoding
+    Struct.new('UserNameAndEmail', :name, :email)
+    Struct.new('UserNameAndDate', :name, :date)
+    Struct.new('Custom', :name, :sub)
+    user_email = Struct::UserNameAndEmail.new 'David', 'sample@example.com'
+    user_birthday = Struct::UserNameAndDate.new 'David', Date.new(2010, 01, 01)
+    custom = Struct::Custom.new 'David', user_birthday
+
+
+    json_strings = ""
+    json_string_and_date = ""
+    json_custom = ""
+
+    assert_nothing_raised do
+      json_strings = user_email.to_json
+      json_string_and_date = user_birthday.to_json
+      json_custom = custom.to_json
+    end
+
+    assert_equal({"name" => "David",
+                  "sub" => {
+                    "name" => "David",
+                    "date" => "2010/01/01" }}, JSON.parse(json_custom))
+
+    assert_equal({"name" => "David", "email" => "sample@example.com"},
+                 JSON.parse(json_strings))
+
+    assert_equal({"name" => "David", "date" => "2010/01/01"},
+                 JSON.parse(json_string_and_date))
+  end
 
   protected
 
diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 9faa11efbc..7b48b3f85b 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -3,14 +3,19 @@ require 'abstract_unit'
 module Notifications
   class TestCase < ActiveSupport::TestCase
     def setup
-      ActiveSupport::Notifications.notifier = nil
-      @notifier = ActiveSupport::Notifications.notifier
+      @old_notifier = ActiveSupport::Notifications.notifier
+      @notifier = ActiveSupport::Notifications::Fanout.new
+      ActiveSupport::Notifications.notifier = @notifier
       @events = []
       @named_events = []
       @subscription = @notifier.subscribe { |*args| @events << event(*args) }
       @named_subscription = @notifier.subscribe("named.subscription") { |*args| @named_events << event(*args) }
     end
 
+    def teardown
+      ActiveSupport::Notifications.notifier = @old_notifier
+    end
+
   private
 
     def event(*args)
diff --git a/activesupport/test/ordered_hash_test.rb b/activesupport/test/ordered_hash_test.rb
index 72088854fc..50168fa78f 100644
--- a/activesupport/test/ordered_hash_test.rb
+++ b/activesupport/test/ordered_hash_test.rb
@@ -78,20 +78,26 @@ class OrderedHashTest < Test::Unit::TestCase
 
   def test_each_key
     keys = []
-    @ordered_hash.each_key { |k| keys << k }
+    assert_equal @ordered_hash, @ordered_hash.each_key { |k| keys << k }
     assert_equal @keys, keys
+    expected_class = RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+    assert_kind_of expected_class, @ordered_hash.each_key
   end
 
   def test_each_value
     values = []
-    @ordered_hash.each_value { |v| values << v }
+    assert_equal @ordered_hash, @ordered_hash.each_value { |v| values << v }
     assert_equal @values, values
+    expected_class = RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+    assert_kind_of expected_class, @ordered_hash.each_value
   end
 
   def test_each
     values = []
-    @ordered_hash.each {|key, value| values << value}
+    assert_equal @ordered_hash, @ordered_hash.each {|key, value| values << value}
     assert_equal @values, values
+    expected_class = RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+    assert_kind_of expected_class, @ordered_hash.each
   end
 
   def test_each_with_index
@@ -239,14 +245,14 @@ class OrderedHashTest < Test::Unit::TestCase
 
   def test_each_after_yaml_serialization
     values = []
-    @deserialized_ordered_hash = YAML::load(YAML::dump(@ordered_hash))
+    @deserialized_ordered_hash = YAML.load(YAML.dump(@ordered_hash))
 
     @deserialized_ordered_hash.each {|key, value| values << value}
     assert_equal @values, values
   end
 
   def test_order_after_yaml_serialization
-    @deserialized_ordered_hash = YAML::load(YAML::dump(@ordered_hash))
+    @deserialized_ordered_hash = YAML.load(YAML.dump(@ordered_hash))
 
     assert_equal @keys,   @deserialized_ordered_hash.keys
     assert_equal @values, @deserialized_ordered_hash.values
@@ -255,12 +261,34 @@ class OrderedHashTest < Test::Unit::TestCase
   def test_order_after_yaml_serialization_with_nested_arrays
     @ordered_hash[:array] = %w(a b c)
 
-    @deserialized_ordered_hash = YAML::load(YAML::dump(@ordered_hash))
+    @deserialized_ordered_hash = YAML.load(YAML.dump(@ordered_hash))
 
     assert_equal @ordered_hash.keys,   @deserialized_ordered_hash.keys
     assert_equal @ordered_hash.values, @deserialized_ordered_hash.values
   end
 
+  begin
+    require 'psych'
+
+    def test_psych_serialize
+      @deserialized_ordered_hash = Psych.load(Psych.dump(@ordered_hash))
+
+      values = @deserialized_ordered_hash.map { |_, value| value }
+      assert_equal @values, values
+    end
+
+    def test_psych_serialize_tag
+      yaml = Psych.dump(@ordered_hash)
+      assert_match '!omap', yaml
+    end
+  rescue LoadError
+  end
+
+  def test_has_yaml_tag
+    @ordered_hash[:array] = %w(a b c)
+    assert_match '!omap', YAML.dump(@ordered_hash)
+  end
+
   def test_update_sets_keys
     @updated_ordered_hash = ActiveSupport::OrderedHash.new
     @updated_ordered_hash.update(:name => "Bob")
diff --git a/activesupport/test/safe_buffer_test.rb b/activesupport/test/safe_buffer_test.rb
index bf61f9e58c..a4e2acbb32 100644
--- a/activesupport/test/safe_buffer_test.rb
+++ b/activesupport/test/safe_buffer_test.rb
@@ -1,4 +1,10 @@
 require 'abstract_unit'
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'yaml'
 
 class SafeBufferTest < ActiveSupport::TestCase
   def setup
@@ -38,4 +44,20 @@ class SafeBufferTest < ActiveSupport::TestCase
     new_buffer = @buffer.to_s
     assert_equal ActiveSupport::SafeBuffer, new_buffer.class
   end
+
+  def test_to_yaml
+    str  = 'hello!'
+    buf  = ActiveSupport::SafeBuffer.new str
+    yaml = buf.to_yaml
+
+    assert_match(/^--- #{str}/, yaml)
+    assert_equal 'hello!', YAML.load(yaml)
+  end
+
+  def test_nested
+    str  = 'hello!'
+    data = { 'str' => ActiveSupport::SafeBuffer.new(str) }
+    yaml = YAML.dump data
+    assert_equal({'str' => str}, YAML.load(yaml))
+  end
 end
diff --git a/activesupport/test/test_xml_mini.rb b/activesupport/test/test_xml_mini.rb
index 309fa234bf..6dbcd1f40b 100644
--- a/activesupport/test/test_xml_mini.rb
+++ b/activesupport/test/test_xml_mini.rb
@@ -1,61 +1,100 @@
 require 'abstract_unit'
 require 'active_support/xml_mini'
+require 'active_support/builder'
 
-class XmlMiniTest < Test::Unit::TestCase
-  def test_rename_key_dasherizes_by_default
-    assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key")
-  end
+module XmlMiniTest
+  class RenameKeyTest < Test::Unit::TestCase
+    def test_rename_key_dasherizes_by_default
+      assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key")
+    end
 
-  def test_rename_key_does_nothing_with_dasherize_true
-    assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => true)
-  end
+    def test_rename_key_does_nothing_with_dasherize_true
+      assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => true)
+    end
 
-  def test_rename_key_does_nothing_with_dasherize_false
-    assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => false)
-  end
+    def test_rename_key_does_nothing_with_dasherize_false
+      assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => false)
+    end
 
-  def test_rename_key_camelizes_with_camelize_false
-    assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :camelize => false)
-  end
+    def test_rename_key_camelizes_with_camelize_false
+      assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :camelize => false)
+    end
 
-  def test_rename_key_camelizes_with_camelize_nil
-    assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :camelize => nil)
-  end
+    def test_rename_key_camelizes_with_camelize_nil
+      assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :camelize => nil)
+    end
 
-  def test_rename_key_camelizes_with_camelize_true
-    assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => true)
-  end
+    def test_rename_key_camelizes_with_camelize_true
+      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => true)
+    end
 
-  def test_rename_key_lower_camelizes_with_camelize_lower
-    assert_equal "myKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :lower)
-  end
+    def test_rename_key_lower_camelizes_with_camelize_lower
+      assert_equal "myKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :lower)
+    end
 
-  def test_rename_key_lower_camelizes_with_camelize_upper
-    assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :upper)
-  end
+    def test_rename_key_lower_camelizes_with_camelize_upper
+      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :upper)
+    end
 
-  def test_rename_key_does_not_dasherize_leading_underscores
-    assert_equal "_id", ActiveSupport::XmlMini.rename_key("_id")
-  end
+    def test_rename_key_does_not_dasherize_leading_underscores
+      assert_equal "_id", ActiveSupport::XmlMini.rename_key("_id")
+    end
 
-  def test_rename_key_with_leading_underscore_dasherizes_interior_underscores
-    assert_equal "_my-key", ActiveSupport::XmlMini.rename_key("_my_key")
-  end
+    def test_rename_key_with_leading_underscore_dasherizes_interior_underscores
+      assert_equal "_my-key", ActiveSupport::XmlMini.rename_key("_my_key")
+    end
 
-  def test_rename_key_does_not_dasherize_trailing_underscores
-    assert_equal "id_", ActiveSupport::XmlMini.rename_key("id_")
-  end
+    def test_rename_key_does_not_dasherize_trailing_underscores
+      assert_equal "id_", ActiveSupport::XmlMini.rename_key("id_")
+    end
 
-  def test_rename_key_with_trailing_underscore_dasherizes_interior_underscores
-    assert_equal "my-key_", ActiveSupport::XmlMini.rename_key("my_key_")
-  end
+    def test_rename_key_with_trailing_underscore_dasherizes_interior_underscores
+      assert_equal "my-key_", ActiveSupport::XmlMini.rename_key("my_key_")
+    end
 
-  def test_rename_key_does_not_dasherize_multiple_leading_underscores
-    assert_equal "__id", ActiveSupport::XmlMini.rename_key("__id")
-  end
+    def test_rename_key_does_not_dasherize_multiple_leading_underscores
+      assert_equal "__id", ActiveSupport::XmlMini.rename_key("__id")
+    end
 
-  def test_rename_key_does_not_dasherize_multiple_leading_underscores
-    assert_equal "id__", ActiveSupport::XmlMini.rename_key("id__")
+    def test_rename_key_does_not_dasherize_multiple_leading_underscores
+      assert_equal "id__", ActiveSupport::XmlMini.rename_key("id__")
+    end  
   end
 
+  class ToTagTest < ActiveSupport::TestCase
+    def assert_xml(xml)
+      assert_equal xml, @options[:builder].target!
+    end
+    
+    setup do
+      @xml = ActiveSupport::XmlMini
+      @options = {:skip_instruct => true, :builder => Builder::XmlMarkup.new}
+    end
+    
+    test "#to_tag accepts a callable object and passes options with the builder" do
+      @xml.to_tag(:some_tag, lambda {|o| o[:builder].br }, @options)
+      assert_xml "<br/>"
+    end
+    
+    test "#to_tag accepts a callable object and passes options and tag name" do
+      @xml.to_tag(:tag, lambda {|o, t| o[:builder].b(t) }, @options)
+      assert_xml "<b>tag</b>"
+    end
+    
+    test "#to_tag accepts an object responding to #to_xml and passes the options, where :root is key" do
+      obj = Object.new
+      obj.instance_eval do
+        def to_xml(options) options[:builder].yo(options[:root].to_s) end
+      end
+      
+      @xml.to_tag(:tag, obj, @options)
+      assert_xml "<yo>tag</yo>"
+    end
+    
+    test "#to_tag accepts arbitrary objects responding to #to_str" do
+      @xml.to_tag(:b, "Howdy", @options)
+      assert_xml "<b>Howdy</b>"
+    end
+    # TODO: test the remaining functions hidden in #to_tag.
+  end
 end