Type transform setting and transformer, name fixed in tests

Author: youroff

docs/general/configuration_options.md

@@ -67,6 +67,17 @@ Possible values:
 
 Sets separator string for namespaced models to render `type` attribute. Default value is `--`.
 
+##### jsonapi_type_transform
+
+Provides transform for `type` attribute. Class name `NicePost` gets converted into `nice_post`, `nice-post`, `NicePost` or `nicePost` depending on selected setting.
+
+Possible values:
+
+- `:underscore` (default)
+- `:dashed`
+- `:camel`
+- `:snake`
+
 ##### jsonapi_include_toplevel_object
 
 Include a [top level jsonapi member](http://jsonapi.org/format/#document-jsonapi-object)

lib/active_model/serializer/configuration.rb

@@ -21,7 +21,8 @@ def config.array_serializer
 
         config.adapter = :attributes
         config.jsonapi_resource_type = :plural
-        config.jsonapi_namespace_separator = '--'
+        config.jsonapi_namespace_separator = '--'.freeze
+        config.jsonapi_type_transform = :underscore
         config.jsonapi_version = '1.0'
         config.jsonapi_toplevel_meta = {}
         # Make JSON API top-level jsonapi member opt-in

lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -21,7 +21,7 @@ def as_json
         def type_for(serializer)
           return serializer._type if serializer._type
           type = serializer.object.class.to_s.split('::')
-          type.map! { |t| t.underscore.downcase }
+          type.map! { |t| KeyTransform.transform(t, ActiveModelSerializers.config.jsonapi_type_transform) }
           type = type.join ActiveModelSerializers.config.jsonapi_namespace_separator
           if ActiveModelSerializers.config.jsonapi_resource_type == :plural
             type = type.pluralize

lib/active_model_serializers/key_transform.rb

@@ -36,5 +36,26 @@ def dashed(hash)
     def unaltered(hash)
       hash
     end
+
+    # Transforms string to selected case
+    # Accepts string in any case: 'camel', 'undescore', 'dashed'.
+    #
+    # @example:
+    #   transform('SomeClass', :underscore) => 'some_class'
+    #   transform('some_class', :snake) => 'someClass'
+    #   etc...
+    def transform(string, type)
+      string = string.underscore
+      case type.to_sym
+      when :dashed
+        string.dasherize
+      when :camel
+        string.camelize
+      when :snake
+        string.camelize(:lower)
+      else
+        string
+      end
+    end
   end
 end

test/adapter/json_api/resource_identifier_test.rb

@@ -22,54 +22,54 @@ class FragmentedSerializer < ActiveModel::Serializer; end
         end
 
         def test_defined_type
-          test(WithDefinedTypeSerializer.new(@model), type: 'with_defined_type')
+          assert_identifier(WithDefinedTypeSerializer.new(@model), type: 'with_defined_type')
         end
 
         def test_singular_type
-          test(AuthorSerializer.new(@model), type: 'author', inflection: :singular)
+          assert_with_confing(AuthorSerializer.new(@model), type: 'author', inflection: :singular)
         end
 
         def test_plural_type
-          test(AuthorSerializer.new(@model), type: 'authors', inflection: :plural)
+          assert_with_confing(AuthorSerializer.new(@model), type: 'authors', inflection: :plural)
         end
 
         def test_type_with_namespace
           spam = Spam::UnrelatedLink.new
-          test(Spam::UnrelatedLinkSerializer.new(spam), type: 'spam--unrelated_links')
+          assert_identifier(Spam::UnrelatedLinkSerializer.new(spam), type: 'spam--unrelated_links')
         end
 
         def test_type_with_custom_namespace
           spam = Spam::UnrelatedLink.new
-          test(Spam::UnrelatedLinkSerializer.new(spam), type: 'spam/unrelated_links', namespace_separator: '/')
+          assert_with_confing(Spam::UnrelatedLinkSerializer.new(spam), type: 'spam/unrelated_links', namespace_separator: '/')
         end
 
         def test_id_defined_on_object
-          test(AuthorSerializer.new(@model), id: @model.id.to_s)
+          assert_identifier(AuthorSerializer.new(@model), id: @model.id.to_s)
         end
 
         def test_id_defined_on_serializer
-          test(WithDefinedIdSerializer.new(@model), id: 'special_id')
+          assert_identifier(WithDefinedIdSerializer.new(@model), id: 'special_id')
         end
 
         def test_id_defined_on_fragmented
           FragmentedSerializer.fragmented(WithDefinedIdSerializer.new(@author))
-          test(FragmentedSerializer.new(@model), id: 'special_id')
+          assert_identifier(FragmentedSerializer.new(@model), id: 'special_id')
         end
 
         private
 
-        def test(serializer, opts = {})
+        def assert_with_confing(serializer, opts = {})
           inflection = ActiveModelSerializers.config.jsonapi_resource_type
           namespace_separator = ActiveModelSerializers.config.jsonapi_namespace_separator
           ActiveModelSerializers.config.jsonapi_resource_type = opts.fetch(:inflection, inflection)
           ActiveModelSerializers.config.jsonapi_namespace_separator = opts.fetch(:namespace_separator, namespace_separator)
-          test_serializer(serializer, opts)
+          assert_identifier(serializer, opts)
         ensure
           ActiveModelSerializers.config.jsonapi_resource_type = inflection
           ActiveModelSerializers.config.jsonapi_namespace_separator = namespace_separator
         end
 
-        def test_serializer(serializer, opts = {})
+        def assert_identifier(serializer, opts = {})
           identifier = ResourceIdentifier.new(serializer)
           expected = {
             id: opts.fetch(:id, identifier.as_json[:id]),