Preserve values from being formatted

Introduce `JSON_API_FORMAT_FIELD_NAMES`. When set preserves keys of values.
`JSON_API_FORMAT_KEYS` still exists and will still format all keys
recursively.

Author: Oliver Sauder

example/tests/test_parsers.py

@@ -1,7 +1,7 @@
 import json
 from io import BytesIO
 
-from django.test import TestCase
+from django.test import TestCase, override_settings
 from rest_framework.exceptions import ParseError
 
 from rest_framework_json_api.parsers import JSONParser
@@ -22,7 +22,10 @@ def __init__(self):
         data = {
             'data': {
                 'id': 123,
-                'type': 'Blog'
+                'type': 'Blog',
+                'attributes': {
+                    'json-value': {'JsonKey': 'JsonValue'}
+                },
             },
             'meta': {
                 'random_key': 'random_value'
@@ -31,13 +34,24 @@ def __init__(self):
 
         self.string = json.dumps(data)
 
-    def test_parse_include_metadata(self):
+    def test_parse_include_metadata_format_keys(self):
         parser = JSONParser()
 
         stream = BytesIO(self.string.encode('utf-8'))
         data = parser.parse(stream, None, self.parser_context)
 
         self.assertEqual(data['_meta'], {'random_key': 'random_value'})
+        self.assertEqual(data['json_value'], {'json_key': 'JsonValue'})
+
+    @override_settings(JSON_API_FORMAT_KEYS=False, JSON_API_FORMAT_FIELD_NAMES='dasherize')
+    def test_parse_include_metadata_format_field_names(self):
+        parser = JSONParser()
+
+        stream = BytesIO(self.string.encode('utf-8'))
+        data = parser.parse(stream, None, self.parser_context)
+
+        self.assertEqual(data['_meta'], {'random_key': 'random_value'})
+        self.assertEqual(data['json_value'], {'JsonKey': 'JsonValue'})
 
     def test_parse_invalid_data(self):
         parser = JSONParser()

example/tests/unit/test_renderers.py

@@ -1,3 +1,5 @@
+import json
+
 from rest_framework_json_api import serializers, views
 from rest_framework_json_api.renderers import JSONRenderer
 
@@ -19,9 +21,14 @@ class DummyTestSerializer(serializers.ModelSerializer):
     related_models = RelatedModelSerializer(
         source='comments', many=True, read_only=True)
 
+    json_field = serializers.SerializerMethodField()
+
+    def get_json_field(self, entry):
+        return {'JsonKey': 'JsonValue'}
+
     class Meta:
         model = Entry
-        fields = ('related_models',)
+        fields = ('related_models', 'json_field')
 
     class JSONAPIMeta:
         included_resources = ('related_models',)
@@ -44,3 +51,18 @@ def test_simple_reverse_relation_included_renderer():
         renderer_context={'view': DummyTestViewSet()})
 
     assert rendered
+
+
+def test_render_format_field_names_only(settings):
+    """Test that json field is kept untouched."""
+    delattr(settings, 'JSON_API_FORMAT_KEYS')
+    settings.JSON_API_FORMAT_FIELD_NAMES = 'dasherize'
+
+    serializer = DummyTestSerializer(instance=Entry())
+    renderer = JSONRenderer()
+    rendered = renderer.render(
+        serializer.data,
+        renderer_context={'view': DummyTestViewSet()})
+
+    result = json.loads(rendered.decode())
+    assert result['data']['attributes']['json-field'] == {'JsonKey': 'JsonValue'}

example/tests/unit/test_utils.py

@@ -84,6 +84,19 @@ def test_format_keys():
     assert utils.format_keys([underscored], 'dasherize') == output
 
 
+@pytest.mark.parametrize("format_type,output", [
+    ('camelize', {'fullName': {'last-name': 'a', 'first-name': 'b'}}),
+    ('capitalize', {'FullName': {'last-name': 'a', 'first-name': 'b'}}),
+    ('dasherize', {'full-name': {'last-name': 'a', 'first-name': 'b'}}),
+    ('underscore', {'full_name': {'last-name': 'a', 'first-name': 'b'}}),
+])
+def test_format_field_names(settings, format_type, output):
+    settings.JSON_API_FORMAT_FIELD_NAMES = format_type
+
+    value = {'full_name': {'last-name': 'a', 'first-name': 'b'}}
+    assert utils.format_keys(value, format_type, False) == output
+
+
 def test_format_value():
     assert utils.format_value('first_name', 'camelize') == 'firstName'
     assert utils.format_value('first_name', 'capitalize') == 'FirstName'

rest_framework_json_api/parsers.py

@@ -29,10 +29,18 @@ class JSONParser(parsers.JSONParser):
     media_type = 'application/vnd.api+json'
     renderer_class = renderers.JSONRenderer
 
+    @staticmethod
+    def _uses_format_translation():
+        return getattr(
+            settings,
+            'JSON_API_FORMAT_FIELD_NAMES',
+            getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        )
+
     @staticmethod
     def parse_attributes(data):
         attributes = data.get('attributes')
-        uses_format_translation = getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        uses_format_translation = JSONParser._uses_format_translation()
 
         if not attributes:
             return dict()
@@ -44,7 +52,7 @@ def parse_attributes(data):
 
     @staticmethod
     def parse_relationships(data):
-        uses_format_translation = getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        uses_format_translation = JSONParser._uses_format_translation()
         relationships = data.get('relationships')
 
         if not relationships:

rest_framework_json_api/utils.py

@@ -96,15 +96,31 @@ def get_serializer_fields(serializer):
         return fields
 
 
-def format_keys(obj, format_type=None):
+def format_keys(obj, format_type=None, recursive=None):
     """
-    Takes either a dict or list and returns it with camelized keys only if
-    JSON_API_FORMAT_KEYS is set.
+    Takes either a dict or list and formats keys as configured in
+    `JSON_API_FORMAT_KEYS` if set. `JSON_API_FIELD_NAMES` takes precedence
+    over `JSON_API_FORMAT_KEYS` but only formats field names preserving
+    values.
 
-    :format_type: Either 'dasherize', 'camelize' or 'underscore'
+    :format_type: Either 'dasherize', 'camelize', 'capitalize' or 'underscore'
+    :recursive: If set all keys will be formatted; otherwise only keys of given object
     """
     if format_type is None:
-        format_type = getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        format_type_field_names = getattr(settings, 'JSON_API_FORMAT_FIELD_NAMES', False)
+        format_type_format_keys = getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+
+        if format_type_field_names and format_type_format_keys:
+            raise RuntimeError(
+                'Setting `JSON_API_FORMAT_FIELD_NAMES` and `JSON_API_FORMAT_KEYS` '
+                'may not both be set.'
+            )
+
+        format_type = format_type_field_names or format_type_format_keys
+
+    # only format keys of values when `FORMAT_KEYS` is set
+    if recursive is None:
+        recursive = bool(getattr(settings, 'JSON_API_FORMAT_KEYS', False))
 
     if format_type in ('dasherize', 'camelize', 'underscore', 'capitalize'):
 
@@ -115,18 +131,18 @@ def format_keys(obj, format_type=None):
                     # inflection can't dasherize camelCase
                     key = inflection.underscore(key)
                     formatted[inflection.dasherize(key)] \
-                        = format_keys(value, format_type)
+                        = recursive and format_keys(value, format_type) or value
                 elif format_type == 'camelize':
                     formatted[inflection.camelize(key, False)] \
-                        = format_keys(value, format_type)
+                        = recursive and format_keys(value, format_type) or value
                 elif format_type == 'capitalize':
                     formatted[inflection.camelize(key)] \
-                        = format_keys(value, format_type)
+                        = recursive and format_keys(value, format_type) or value
                 elif format_type == 'underscore':
                     formatted[inflection.underscore(key)] \
-                        = format_keys(value, format_type)
+                        = recursive and format_keys(value, format_type) or value
             return formatted
-        if isinstance(obj, list):
+        if isinstance(obj, list) and recursive:
             return [format_keys(item, format_type) for item in obj]
         else:
             return obj
@@ -136,7 +152,11 @@ def format_keys(obj, format_type=None):
 
 def format_value(value, format_type=None):
     if format_type is None:
-        format_type = getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        format_type = getattr(
+            settings,
+            'JSON_API_FORMAT_FIELD_NAMES',
+            getattr(settings, 'JSON_API_FORMAT_KEYS', False)
+        )
     if format_type == 'dasherize':
         # inflection can't dasherize camelCase
         value = inflection.underscore(value)