Provide key case translation

Author: remear

lib/action_controller/serialization.rb

@@ -56,7 +56,9 @@ def use_adapter?
 
     [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
       define_method renderer_method do |resource, options|
-        options.fetch(:serialization_context) { options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request) }
+        options.fetch(:serialization_context) do
+          options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request, options)
+        end
         serializable_resource = get_serializer(resource, options)
         super(serializable_resource, options)
       end

lib/active_model_serializers/adapter/base.rb

@@ -1,6 +1,9 @@
+require 'active_model_serializers/key_transform'
+
 module ActiveModelSerializers
   module Adapter
     class Base
+      include ActiveModelSerializers::KeyTransform
       # Automatically register adapters when subclassing
       def self.inherited(subclass)
         ActiveModelSerializers::Adapter.register(subclass)
@@ -51,6 +54,16 @@ def include_meta(json)
         json[meta_key] = meta if meta
         json
       end
+
+      def default_key_transform
+        :unaltered
+      end
+
+      def transform_key_casing!(value, serialization_context)
+        return value unless serialization_context
+        transform = serialization_context.key_transform || default_key_transform
+        KeyTransform.send(transform, value)
+      end
     end
   end
 end

lib/active_model_serializers/adapter/json.rb

@@ -3,7 +3,8 @@ module Adapter
     class Json < Base
       def serializable_hash(options = nil)
         options ||= {}
-        { root => Attributes.new(serializer, instance_options).serializable_hash(options) }
+        serialized_hash = { root => Attributes.new(serializer, instance_options).serializable_hash(options) }
+        transform_key_casing!(serialized_hash, options[:serialization_context])
       end
     end
   end

lib/active_model_serializers/adapter/json_api.rb

@@ -37,15 +37,20 @@ def initialize(serializer, options = {})
         @fieldset = options[:fieldset] || ActiveModel::Serializer::Fieldset.new(options.delete(:fields))
       end
 
+      def default_key_transform
+        :dashed
+      end
+
       # {http://jsonapi.org/format/#crud Requests are transactional, i.e. success or failure}
       # {http://jsonapi.org/format/#document-top-level data and errors MUST NOT coexist in the same document.}
       def serializable_hash(options = nil)
         options ||= {}
-        if serializer.success?
-          success_document(options)
-        else
-          failure_document
-        end
+        document = if serializer.success?
+                     success_document(options)
+                   else
+                     failure_document
+                   end
+        transform_key_casing!(document, options[:serialization_context])
       end
 
       # {http://jsonapi.org/format/#document-top-level Primary data}

lib/active_model_serializers/key_transform.rb

@@ -0,0 +1,38 @@
+module ActiveModelSerializers
+  module KeyTransform
+    # Transforms keys to UpperCamelCase or PascalCase.
+    #
+    # @example:
+    #    "some_key" => "SomeKey",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
+    def camel(hash)
+      hash.deep_transform_keys! { |key| key.to_s.camelize.to_sym }
+    end
+
+    # Transforms keys to camelCase.
+    #
+    # @example:
+    #    "some_key" => "someKey",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
+    def camel_lower(hash)
+      hash.deep_transform_keys! { |key| key.to_s.camelize(:lower).to_sym }
+    end
+
+    # Transforms keys to dashed-case.
+    # This is the default case for the JsonApi adapter.
+    #
+    # @example:
+    #    "some_key" => "some-key",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L185-L187 ActiveSupport::Inflector.dasherize}
+    def dashed(hash)
+      hash.deep_transform_keys! { |key| key.to_s.dasherize.to_sym }
+    end
+
+    # Returns the hash unaltered
+    def unaltered(hash)
+      hash
+    end
+
+    module_function :camel, :camel_lower, :dashed, :unaltered
+  end
+end

lib/active_model_serializers/serialization_context.rb

@@ -4,13 +4,14 @@ class << self
       attr_writer :url_helpers, :default_url_options
     end
 
-    attr_reader :request_url, :query_parameters
+    attr_reader :request_url, :query_parameters, :key_transform
 
     def initialize(request, options = {})
       @request_url = request.original_url[/\A[^?]+/]
       @query_parameters = request.query_parameters
       @url_helpers = options.delete(:url_helpers) || self.class.url_helpers
       @default_url_options = options.delete(:default_url_options) || self.class.default_url_options
+      @key_transform = options.delete(:key_transform)
     end
 
     def self.url_helpers

test/adapter/json/key_case_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class Json
+      class KeyCaseTest < ActiveSupport::TestCase
+        def mock_request(key_transform = nil)
+          context = Minitest::Mock.new
+          context.expect(:request_url, URI)
+          context.expect(:query_parameters, {})
+          context.expect(:key_transform, key_transform)
+          @options = {}
+          @options[:serialization_context] = context
+        end
+
+        Post = Class.new(::Model)
+        class PostSerializer < ActiveModel::Serializer
+          attributes :id, :title, :body, :publish_at
+        end
+
+        def setup
+          ActionController::Base.cache_store.clear
+          @blog = Blog.new(id: 1, name: 'My Blog!!', special_attribute: 'neat')
+          serializer = CustomBlogSerializer.new(@blog)
+          @adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
+        end
+
+        def test_key_transform_default
+          mock_request
+          assert_equal({
+            blog: { id: 1, special_attribute: 'neat', articles: nil }
+          }, @adapter.serializable_hash(@options))
+        end
+
+        def test_key_transform_undefined
+          mock_request(:blam)
+          result = nil
+          assert_raises NoMethodError do
+            result = @adapter.serializable_hash(@options)
+          end
+        end
+
+        def test_key_transform_dashed
+          mock_request(:dashed)
+          assert_equal({
+            blog: { id: 1, :"special-attribute" => 'neat', articles: nil }
+          }, @adapter.serializable_hash(@options))
+        end
+
+        def test_key_transform_unaltered
+          mock_request(:unaltered)
+          assert_equal({
+            blog: { id: 1, special_attribute: 'neat', articles: nil }
+          }, @adapter.serializable_hash(@options))
+        end
+
+        def test_key_transform_camel
+          mock_request(:camel)
+          assert_equal({
+            Blog: { Id: 1, SpecialAttribute: 'neat', Articles: nil }
+          }, @adapter.serializable_hash(@options))
+        end
+
+        def test_key_transform_camel_lower
+          mock_request(:camel_lower)
+          assert_equal({
+            blog: { id: 1, specialAttribute: 'neat', articles: nil }
+          }, @adapter.serializable_hash(@options))
+        end
+      end
+    end
+  end
+end