Rails 2.3.3.1

Update to latest Rails.
A little bit of jiggery-pokery is involved, since they
neglected to re-include vendored Rack in this release.

vendor/rails/activesupport/test/json/encoding_test.rb

@@ -8,6 +8,12 @@ class TestJSONEncoding < Test::Unit::TestCase
     end
   end
 
+  class Custom
+    def to_json(options)
+      '"custom"'
+    end
+  end
+
   TrueTests     = [[ true,  %(true)  ]]
   FalseTests    = [[ false, %(false) ]]
   NilTests      = [[ nil,   %(null)  ]]
@@ -18,14 +24,15 @@ class TestJSONEncoding < Test::Unit::TestCase
                    [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
                    [ 'http://test.host/posts/1', %("http://test.host/posts/1")]]
 
-  ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\", \"b\", \"c\"])          ],
-                   [ [1, 'a', :b, nil, false], %([1, \"a\", \"b\", null, false]) ]]
+  ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])          ],
+                   [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
 
   SymbolTests   = [[ :a,     %("a")    ],
                    [ :this,  %("this") ],
                    [ :"a b", %("a b")  ]]
 
-  ObjectTests   = [[ Foo.new(1, 2), %({\"a\": 1, \"b\": 2}) ]]
+  ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
+  CustomTests   = [[ Custom.new, '"custom"' ]]
 
   VariableTests = [[ ActiveSupport::JSON::Variable.new('foo'), 'foo'],
                    [ ActiveSupport::JSON::Variable.new('alert("foo")'), 'alert("foo")']]
@@ -46,7 +53,7 @@ class TestJSONEncoding < Test::Unit::TestCase
         ActiveSupport.escape_html_entities_in_json  = class_tests !~ /^Standard/
         ActiveSupport.use_standard_json_time_format = class_tests =~ /^Standard/
         self.class.const_get(class_tests).each do |pair|
-          assert_equal pair.last, pair.first.to_json
+          assert_equal pair.last, ActiveSupport::JSON.encode(pair.first)
         end
       ensure
         ActiveSupport.escape_html_entities_in_json  = false
@@ -56,45 +63,50 @@ class TestJSONEncoding < Test::Unit::TestCase
   end
 
   def test_hash_encoding
-    assert_equal %({\"a\": \"b\"}), { :a => :b }.to_json
-    assert_equal %({\"a\": 1}), { 'a' => 1  }.to_json
-    assert_equal %({\"a\": [1, 2]}), { 'a' => [1,2] }.to_json
-    assert_equal %({"1": 2}), { 1 => 2 }.to_json
+    assert_equal %({\"a\":\"b\"}), ActiveSupport::JSON.encode(:a => :b)
+    assert_equal %({\"a\":1}),     ActiveSupport::JSON.encode('a' => 1)
+    assert_equal %({\"a\":[1,2]}), ActiveSupport::JSON.encode('a' => [1,2])
+    assert_equal %({"1":2}),       ActiveSupport::JSON.encode(1 => 2)
 
-    sorted_json = '{' + {:a => :b, :c => :d}.to_json[1..-2].split(', ').sort.join(', ') + '}'
-    assert_equal %({\"a\": \"b\", \"c\": \"d\"}), sorted_json
+    sorted_json = '{' + ActiveSupport::JSON.encode(:a => :b, :c => :d)[1..-2].split(',').sort.join(',') + '}'
+    assert_equal %({\"a\":\"b\",\"c\":\"d\"}), sorted_json
   end
 
   def test_utf8_string_encoded_properly_when_kcode_is_utf8
     with_kcode 'UTF8' do
-      assert_equal '"\\u20ac2.99"', '€2.99'.to_json
-      assert_equal '"\\u270e\\u263a"', '✎☺'.to_json
+      result = ActiveSupport::JSON.encode('€2.99')
+      assert_equal '"\\u20ac2.99"', result
+      assert_equal(Encoding::UTF_8, result.encoding) if result.respond_to?(:encoding)
+
+      result = ActiveSupport::JSON.encode('✎☺')
+      assert_equal '"\\u270e\\u263a"', result
+      assert_equal(Encoding::UTF_8, result.encoding) if result.respond_to?(:encoding)
     end
   end
 
   def test_exception_raised_when_encoding_circular_reference
     a = [1]
     a << a
-    assert_raise(ActiveSupport::JSON::CircularReferenceError) { a.to_json }
+    assert_raise(ActiveSupport::JSON::Encoding::CircularReferenceError) { ActiveSupport::JSON.encode(a) }
   end
 
   def test_hash_key_identifiers_are_always_quoted
     values = {0 => 0, 1 => 1, :_ => :_, "$" => "$", "a" => "a", :A => :A, :A0 => :A0, "A0B" => "A0B"}
-    assert_equal %w( "$" "A" "A0" "A0B" "_" "a" "0" "1" ).sort, object_keys(values.to_json)
+    assert_equal %w( "$" "A" "A0" "A0B" "_" "a" "0" "1" ).sort, object_keys(ActiveSupport::JSON.encode(values))
   end
 
   def test_hash_should_allow_key_filtering_with_only
-    assert_equal %({"a": 1}), { 'a' => 1, :b => 2, :c => 3 }.to_json(:only => 'a')
+    assert_equal %({"a":1}), ActiveSupport::JSON.encode({'a' => 1, :b => 2, :c => 3}, :only => 'a')
   end
 
   def test_hash_should_allow_key_filtering_with_except
-    assert_equal %({"b": 2}), { 'foo' => 'bar', :b => 2, :c => 3 }.to_json(:except => ['foo', :c])
+    assert_equal %({"b":2}), ActiveSupport::JSON.encode({'foo' => 'bar', :b => 2, :c => 3}, :except => ['foo', :c])
   end
   
   def test_time_to_json_includes_local_offset
     ActiveSupport.use_standard_json_time_format = true
     with_env_tz 'US/Eastern' do
-      assert_equal %("2005-02-01T15:15:10-05:00"), Time.local(2005,2,1,15,15,10).to_json
+      assert_equal %("2005-02-01T15:15:10-05:00"), ActiveSupport::JSON.encode(Time.local(2005,2,1,15,15,10))
     end
   ensure
     ActiveSupport.use_standard_json_time_format = false
@@ -108,7 +120,7 @@ class TestJSONEncoding < Test::Unit::TestCase
           :latitude => 123.234
         }
       }
-      result = hash.to_json
+      result = ActiveSupport::JSON.encode(hash)
     end
   end
 
@@ -127,6 +139,16 @@ class TestJSONEncoding < Test::Unit::TestCase
 end
 
 class JsonOptionsTests < Test::Unit::TestCase
+  # The json extension passes internal state to to_json
+  def test_non_hash_options_should_be_tolerated
+    faux_internal_state_object = Object.new
+
+    value = Object.new
+    def value.to_json(options) options end
+
+    assert_kind_of Hash, ActiveSupport::JSON.encode(value, faux_internal_state_object)
+  end
+
   def test_enumerable_should_passthrough_options_to_elements
     json_options = { :include => :posts }
     ActiveSupport::JSON.expects(:encode).with(1, json_options)