JSON serialized attributes can return symbolized keys

- `ActiveRecord::Coder::JSON` can be instantiated with options
- `ActiveSupport::JSON` now accepts options

Author: matthaigh27

activerecord/CHANGELOG.md

@@ -1,3 +1,11 @@
+*   `ActiveRecord::Coder::JSON` can be instantiated
+
+    Options can now be passed to `ActiveRecord::Coder::JSON` when instantiating the coder. This allows:
+    ```ruby
+    serialize :config, coder: ActiveRecord::Coder::JSON.new(symbolize_names: true)
+    ```
+    *matthaigh27*
+
 *   Deprecate using `insert_all`/`upsert_all` with unpersisted records in associations.
 
     Using these methods on associations containing unpersisted records will now

activerecord/lib/active_record/attribute_methods/serialization.rb

@@ -219,10 +219,11 @@ def build_column_serializer(attr_name, coder, type, yaml = nil)
             # When ::JSON is used, force it to go through the Active Support JSON encoder
             # to ensure special objects (e.g. Active Record models) are dumped correctly
             # using the #as_json hook.
-            coder = Coders::JSON if coder == ::JSON
 
             if coder == ::YAML || coder == Coders::YAMLColumn
               Coders::YAMLColumn.new(attr_name, type, **(yaml || {}))
+            elsif coder == ::JSON || coder == Coders::JSON
+              Coders::JSON.new
             elsif coder.respond_to?(:new) && !coder.respond_to?(:load)
               coder.new(attr_name, type)
             elsif type && type != Object

activerecord/lib/active_record/coders/json.rb

@@ -2,13 +2,17 @@
 
 module ActiveRecord
   module Coders # :nodoc:
-    module JSON # :nodoc:
-      def self.dump(obj)
+    class JSON # :nodoc:
+      def initialize(options = {})
+        @options = options
+      end
+
+      def dump(obj)
         ActiveSupport::JSON.encode(obj)
       end
 
-      def self.load(json)
-        ActiveSupport::JSON.decode(json) unless json.blank?
+      def load(json)
+        ActiveSupport::JSON.decode(json, @options) unless json.blank?
       end
     end
   end

activerecord/test/cases/coders/json_test.rb

@@ -6,11 +6,18 @@ module ActiveRecord
   module Coders
     class JSONTest < ActiveRecord::TestCase
       def test_returns_nil_if_empty_string_given
-        assert_nil JSON.load("")
+        coder = JSON.new
+        assert_nil coder.load("")
       end
 
       def test_returns_nil_if_nil_given
-        assert_nil JSON.load(nil)
+        coder = JSON.new
+        assert_nil coder.load(nil)
+      end
+
+      def test_coder_with_symbolize_names
+        coder = JSON.new(symbolize_names: true)
+        assert_equal({ foo: "bar" }, coder.load('{"foo":"bar"}'))
       end
     end
   end

activerecord/test/cases/serialized_attribute_test.rb

@@ -149,6 +149,17 @@ def test_json_read_db_null
     assert_nil t.content
   end
 
+  def test_json_symbolize_names_returns_symbolized_names
+    Topic.serialize :content, coder: ActiveRecord::Coders::JSON.new(symbolize_names: true)
+    my_post = posts(:welcome)
+
+    t = Topic.new(content: my_post)
+    t.save!
+    t.reload
+
+    assert_equal(t.content, t.content.deep_symbolize_keys)
+  end
+
   def test_serialized_attribute_declared_in_subclass
     hash = { "important1" => "value1", "important2" => "value2" }
     important_topic = ImportantTopic.create("important" => hash)

activesupport/CHANGELOG.md

@@ -1,3 +1,12 @@
+*   `ActiveSupport::JSON` now accepts options
+
+    It is now possible to pass options to `ActiveSupport::JSON`:
+    ```ruby
+    ActiveSupport::JSON.decode('{"key": "value"}', symbolize_names: true) # => { key: "value" }
+    ```
+
+    *matthaigh27*
+
 *   `ActiveSupport::Testing::NotificationAssertions`'s `assert_notification` now matches against payload subsets by default.
 
     Previously the following assertion would fail due to excess key vals in the notification payload. Now with payload subset matching, it will pass.

activesupport/lib/active_support/json/decoding.rb

@@ -19,8 +19,8 @@ class << self
       #
       #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
       #   => {"team" => "rails", "players" => "36"}
-      def decode(json)
-        data = ::JSON.parse(json)
+      def decode(json, options = {})
+        data = ::JSON.parse(json, options)
 
         if ActiveSupport.parse_json_times
           convert_dates_from(data)

activesupport/test/json/decoding_test.rb

@@ -110,8 +110,11 @@ def test_failed_json_decoding
     assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%()) }
   end
 
-  def test_cannot_pass_unsupported_options
-    assert_raise(ArgumentError) { ActiveSupport::JSON.decode("", create_additions: true) }
+  def test_symbolized_names_option
+    json = '{"foo":"bar"}'
+    assert_equal({ "foo" => "bar" }, ActiveSupport::JSON.decode(json))
+    assert_equal({ foo: "bar" }, ActiveSupport::JSON.decode(json, symbolize_names: true))
+    assert_equal({ foo: "bar" }, ActiveSupport::JSON.decode(json, { symbolize_names: true }))
   end
 
   private