* Add pluggable JSON backends with support for the JSON gem. [rick]

    Example: ActiveSupport::JSON.backend = "JSONGem"

  All internal Rails JSON encoding is now handled by ActiveSupport::JSON.encode().  Use of #to_json is not recommended, as it may clash with other libraries that overwrite it.  However, you can recover Rails specific functionality
  if you really want to use #to_json.

    gem 'json'
    ActiveSupport::JSON.backend = "JSONGem"

    class ActiveRecord::Base
      alias to_json rails_to_json
    end

3 files changed, 72 insertions, 46 deletions

diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 612a50c225..0380c28c17 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -57,12 +57,12 @@ class TimeWithZoneTest < Test::Unit::TestCase
   end
 
   def test_to_json
-    assert_equal "\"1999/12/31 19:00:00 -0500\"", @twz.to_json
+    assert_equal "\"1999/12/31 19:00:00 -0500\"", ActiveSupport::JSON.encode(@twz)
   end
 
   def test_to_json_with_use_standard_json_time_format_config_set_to_true
     old, ActiveSupport.use_standard_json_time_format = ActiveSupport.use_standard_json_time_format, true
-    assert_equal "\"1999-12-31T19:00:00-05:00\"", @twz.to_json
+    assert_equal "\"1999-12-31T19:00:00-05:00\"", ActiveSupport::JSON.encode(@twz)
   ensure
     ActiveSupport.use_standard_json_time_format = old
   end
diff --git a/activesupport/test/json/decoding_test.rb b/activesupport/test/json/decoding_test.rb
index 9b4b207c88..7e1bfcca84 100644
--- a/activesupport/test/json/decoding_test.rb
+++ b/activesupport/test/json/decoding_test.rb
@@ -1,49 +1,75 @@
 # encoding: UTF-8
 require 'abstract_unit'
 require 'active_support/json'
+require 'active_support/core_ext/kernel/reporting'
 
 class TestJSONDecoding < ActiveSupport::TestCase
   TESTS = {
     %q({"returnTo":{"\/categories":"\/"}})        => {"returnTo" => {"/categories" => "/"}},
-    %q({returnTo:{"\/categories":"\/"}})          => {"returnTo" => {"/categories" => "/"}},
     %q({"return\\"To\\":":{"\/categories":"\/"}}) => {"return\"To\":" => {"/categories" => "/"}},
     %q({"returnTo":{"\/categories":1}})          => {"returnTo" => {"/categories" => 1}},
     %({"returnTo":[1,"a"]})                    => {"returnTo" => [1, "a"]},
     %({"returnTo":[1,"\\"a\\",", "b"]})        => {"returnTo" => [1, "\"a\",", "b"]},
-    %({a: "'", "b": "5,000"})                  => {"a" => "'", "b" => "5,000"},
-    %({a: "a's, b's and c's", "b": "5,000"})   => {"a" => "a's, b's and c's", "b" => "5,000"},
+    %({"a": "'", "b": "5,000"})                  => {"a" => "'", "b" => "5,000"},
+    %({"a": "a's, b's and c's", "b": "5,000"})   => {"a" => "a's, b's and c's", "b" => "5,000"},
     # multibyte
     %({"matzue": "松江", "asakusa": "浅草"}) => {"matzue" => "松江", "asakusa" => "浅草"},
-    %({a: "2007-01-01"})                       => {'a' => Date.new(2007, 1, 1)}, 
-    %({a: "2007-01-01 01:12:34 Z"})            => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)}, 
+    %({"a": "2007-01-01"})                       => {'a' => Date.new(2007, 1, 1)}, 
+    %({"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"}, 
+    %({"a": "2007-01-01 01:12:34"})              => {'a' => "2007-01-01 01:12:34"}, 
     # 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"},
+    %({"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"},
     %([])    => [],
     %({})    => {},
-    %(1)     => 1,
-    %("")    => "",
-    %("\\"") => "\"",
-    %(null)  => nil,
-    %(true)  => true,
-    %(false) => false,
-    %q("http:\/\/test.host\/posts\/1") => "http://test.host/posts/1",
-    %q("\u003cunicode\u0020escape\u003e") => "<unicode escape>",
-    %q("\\\\u0020skip double backslashes") => "\\u0020skip double backslashes",
-    %q({a: "\u003cbr /\u003e"}) => {'a' => "<br />"},
-    %q({b:["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => {'b' => ["<i>","<b>","<u>"]}
+    %({"a":1})     => {"a" => 1},
+    %({"a": ""})    => {"a" => ""},
+    %({"a":"\\""}) => {"a" => "\""},
+    %({"a": null})  => {"a" => nil},
+    %({"a": true})  => {"a" => true},
+    %({"a": false}) => {"a" => false},
+    %q({"a": "http:\/\/test.host\/posts\/1"}) => {"a" => "http://test.host/posts/1"},
+    %q({"a": "\u003cunicode\u0020escape\u003e"}) => {"a" => "<unicode escape>"},
+    %q({"a": "\\\\u0020skip double backslashes"}) => {"a" => "\\u0020skip double backslashes"},
+    %q({"a": "\u003cbr /\u003e"}) => {'a' => "<br />"},
+    %q({"b":["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => {'b' => ["<i>","<b>","<u>"]}
   }
-  
-  TESTS.each do |json, expected|
-    test "json decodes #{json}" do
-      assert_nothing_raised do
-        assert_equal expected, ActiveSupport::JSON.decode(json)
+
+  backends = %w(Yaml)
+  begin
+    gem 'json', '>= 1.1'
+    require 'json'
+    backends << "JSONGem"
+  rescue Gem::LoadError
+    # Skip JSON gem tests
+  end
+
+  backends.each do |backend|
+    TESTS.each do |json, expected|
+      test "json decodes #{json} with the #{backend} backend" do
+        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
+          end
+        end
+      end
+    end
+  end
+
+  if backends.include?("JSONGem")
+    test "json decodes time json with time parsing disabled" do
+      ActiveSupport.parse_json_times = false
+      expected = {"a" => "2007-01-01 01:12:34 Z"}
+      ActiveSupport::JSON.with_backend "JSONGem" do
+        assert_equal expected, ActiveSupport::JSON.decode(%({"a": "2007-01-01 01:12:34 Z"}))
       end
     end
   end
-  
+
   def test_failed_json_decoding
     assert_raise(ActiveSupport::JSON::ParseError) { ActiveSupport::JSON.decode(%({: 1})) }
   end
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index 9e6b4fa501..db24b3d96a 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -19,14 +19,14 @@ 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}) ]]
 
   VariableTests = [[ ActiveSupport::JSON::Variable.new('foo'), 'foo'],
                    [ ActiveSupport::JSON::Variable.new('alert("foo")'), 'alert("foo")']]
@@ -47,7 +47,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
@@ -57,45 +57,45 @@ 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
+      assert_equal '"\\u20ac2.99"', ActiveSupport::JSON.encode('€2.99')
+      assert_equal '"\\u270e\\u263a"', ActiveSupport::JSON.encode('✎☺')
     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::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
@@ -109,7 +109,7 @@ class TestJSONEncoding < Test::Unit::TestCase
           :latitude => 123.234
         }
       }
-      result = hash.to_json
+      result = ActiveSupport::JSON.encode(hash)
     end
   end
 
@@ -134,6 +134,6 @@ class JsonOptionsTests < Test::Unit::TestCase
     ActiveSupport::JSON.expects(:encode).with(2, json_options)
     ActiveSupport::JSON.expects(:encode).with('foo', json_options)
 
-    [1, 2, 'foo'].to_json(json_options)
+    [1, 2, 'foo'].rails_to_json(json_options)
   end
 end