Preserve field names when no formatting is configured (#909)

This way it is possible to have field names which do not follow the python
underscore convention.

Author: sliverc

CHANGELOG.md

@@ -18,6 +18,12 @@ any parts of the framework not mentioned in the documentation should generally b
 ### Fixed
 
 * Allow `get_serializer_class` to be overwritten when using related urls without defining `serializer_class` fallback
+* Preserve field names when no formatting is configured.
+
+### Deprecated
+
+* Deprecated default `format_type` argument of `rest_framework_json_api.utils.format_value`. Use `rest_framework_json_api.utils.format_field_name` or specify specifc `format_type` instead.
+* Deprecated `format_type` argument of `rest_framework_json_api.utils.format_link_segment`. Use `format_value` instead.
 
 ## [4.1.0] - 2021-03-08
 

rest_framework_json_api/django_filters/backends.py

@@ -4,7 +4,7 @@
 from rest_framework.exceptions import ValidationError
 from rest_framework.settings import api_settings
 
-from rest_framework_json_api.utils import format_value
+from rest_framework_json_api.utils import undo_format_field_name
 
 
 class DjangoFilterBackend(DjangoFilterBackend):
@@ -119,8 +119,7 @@ def get_filterset_kwargs(self, request, queryset, view):
                     )
                 # convert jsonapi relationship path to Django ORM's __ notation
                 key = m.groupdict()["assoc"].replace(".", "__")
-                # undo JSON_API_FORMAT_FIELD_NAMES conversion:
-                key = format_value(key, "underscore")
+                key = undo_format_field_name(key)
                 data.setlist(key, val)
                 filter_keys.append(key)
                 del data[qp]

rest_framework_json_api/filters.py

@@ -3,7 +3,7 @@
 from rest_framework.exceptions import ValidationError
 from rest_framework.filters import BaseFilterBackend, OrderingFilter
 
-from rest_framework_json_api.utils import format_value
+from rest_framework_json_api.utils import undo_format_field_name
 
 
 class OrderingFilter(OrderingFilter):
@@ -15,7 +15,7 @@ class OrderingFilter(OrderingFilter):
     :py:class:`rest_framework.filters.OrderingFilter` with
     :py:attr:`~rest_framework.filters.OrderingFilter.ordering_param` = "sort"
 
-    Also applies DJA format_value() to convert (e.g. camelcase) to underscore.
+    Also supports undo of field name formatting
     (See JSON_API_FORMAT_FIELD_NAMES in docs/usage.md)
     """
 
@@ -38,7 +38,7 @@ def remove_invalid_fields(self, queryset, fields, view, request):
         bad_terms = [
             term
             for term in fields
-            if format_value(term.replace(".", "__").lstrip("-"), "underscore")
+            if undo_format_field_name(term.replace(".", "__").lstrip("-"))
             not in valid_fields
         ]
         if bad_terms:
@@ -56,10 +56,10 @@ def remove_invalid_fields(self, queryset, fields, view, request):
             item_rewritten = item.replace(".", "__")
             if item_rewritten.startswith("-"):
                 underscore_fields.append(
-                    "-" + format_value(item_rewritten.lstrip("-"), "underscore")
+                    "-" + undo_format_field_name(item_rewritten.lstrip("-"))
                 )
             else:
-                underscore_fields.append(format_value(item_rewritten, "underscore"))
+                underscore_fields.append(undo_format_field_name(item_rewritten))
 
         return super(OrderingFilter, self).remove_invalid_fields(
             queryset, underscore_fields, view, request

rest_framework_json_api/metadata.py

@@ -7,7 +7,7 @@
 from rest_framework.settings import api_settings
 from rest_framework.utils.field_mapping import ClassLookupDict
 
-from rest_framework_json_api.utils import format_value, get_related_resource_type
+from rest_framework_json_api.utils import format_field_name, get_related_resource_type
 
 
 class JSONAPIMetadata(SimpleMetadata):
@@ -93,7 +93,7 @@ def get_serializer_info(self, serializer):
 
         return OrderedDict(
             [
-                (format_value(field_name), self.get_field_info(field))
+                (format_field_name(field_name), self.get_field_info(field))
                 for field_name, field in serializer.fields.items()
             ]
         )

rest_framework_json_api/parsers.py

@@ -4,8 +4,8 @@
 from rest_framework import parsers
 from rest_framework.exceptions import ParseError
 
-from . import exceptions, renderers, serializers, utils
-from .settings import json_api_settings
+from rest_framework_json_api import exceptions, renderers, serializers
+from rest_framework_json_api.utils import get_resource_name, undo_format_field_names
 
 
 class JSONParser(parsers.JSONParser):
@@ -37,27 +37,13 @@ class JSONParser(parsers.JSONParser):
 
     @staticmethod
     def parse_attributes(data):
-        attributes = data.get("attributes")
-        uses_format_translation = json_api_settings.FORMAT_FIELD_NAMES
-
-        if not attributes:
-            return dict()
-        elif uses_format_translation:
-            # convert back to python/rest_framework's preferred underscore format
-            return utils.format_field_names(attributes, "underscore")
-        else:
-            return attributes
+        attributes = data.get("attributes") or dict()
+        return undo_format_field_names(attributes)
 
     @staticmethod
     def parse_relationships(data):
-        uses_format_translation = json_api_settings.FORMAT_FIELD_NAMES
-        relationships = data.get("relationships")
-
-        if not relationships:
-            relationships = dict()
-        elif uses_format_translation:
-            # convert back to python/rest_framework's preferred underscore format
-            relationships = utils.format_field_names(relationships, "underscore")
+        relationships = data.get("relationships") or dict()
+        relationships = undo_format_field_names(relationships)
 
         # Parse the relationships
         parsed_relationships = dict()
@@ -130,7 +116,7 @@ def parse(self, stream, media_type=None, parser_context=None):
 
         # Check for inconsistencies
         if request.method in ("PUT", "POST", "PATCH"):
-            resource_name = utils.get_resource_name(
+            resource_name = get_resource_name(
                 parser_context, expand_polymorphic_types=True
             )
             if isinstance(resource_name, str):

rest_framework_json_api/utils.py

@@ -1,6 +1,7 @@
 import copy
 import inspect
 import operator
+import warnings
 from collections import OrderedDict
 
 import inflection
@@ -118,8 +119,76 @@ def format_field_names(obj, format_type=None):
     return obj
 
 
+def undo_format_field_names(obj):
+    """
+    Takes a dict and undo format field names to underscore which is the Python convention
+    but only in case `JSON_API_FORMAT_FIELD_NAMES` is actually configured.
+    """
+    if json_api_settings.FORMAT_FIELD_NAMES:
+        return format_field_names(obj, "underscore")
+
+    return obj
+
+
+def format_field_name(field_name):
+    """
+    Takes a field name and returns it with formatted keys as set in
+    `JSON_API_FORMAT_FIELD_NAMES`
+    """
+    return format_value(field_name, json_api_settings.FORMAT_FIELD_NAMES)
+
+
+def undo_format_field_name(field_name):
+    """
+    Takes a string and undos format field name to underscore which is the Python convention
+    but only in case `JSON_API_FORMAT_FIELD_NAMES` is actually configured.
+    """
+    if json_api_settings.FORMAT_FIELD_NAMES:
+        return format_value(field_name, "underscore")
+
+    return field_name
+
+
+def format_link_segment(value, format_type=None):
+    """
+    Takes a string value and returns it with formatted keys as set in `format_type`
+    or `JSON_API_FORMAT_RELATED_LINKS`.
+
+    :format_type: Either 'dasherize', 'camelize', 'capitalize' or 'underscore'
+    """
+    if format_type is None:
+        format_type = json_api_settings.FORMAT_RELATED_LINKS
+    else:
+        warnings.warn(
+            DeprecationWarning(
+                "Using `format_type` argument is deprecated."
+                "Use `format_value` instead."
+            )
+        )
+
+    return format_value(value, format_type)
+
+
+def undo_format_link_segment(value):
+    """
+    Takes a link segment and undos format link segment to underscore which is the Python convention
+    but only in case `JSON_API_FORMAT_RELATED_LINKS` is actually configured.
+    """
+
+    if json_api_settings.FORMAT_RELATED_LINKS:
+        return format_value(value, "underscore")
+
+    return value
+
+
 def format_value(value, format_type=None):
     if format_type is None:
+        warnings.warn(
+            DeprecationWarning(
+                "Using `format_value` without passing on `format_type` argument is deprecated."
+                "Use `format_field_name` instead."
+            )
+        )
         format_type = json_api_settings.FORMAT_FIELD_NAMES
     if format_type == "dasherize":
         # inflection can't dasherize camelCase
@@ -142,25 +211,11 @@ def format_resource_type(value, format_type=None, pluralize=None):
         pluralize = json_api_settings.PLURALIZE_TYPES
 
     if format_type:
-        # format_type will never be None here so we can use format_value
         value = format_value(value, format_type)
 
     return inflection.pluralize(value) if pluralize else value
 
 
-def format_link_segment(value, format_type=None):
-    """
-    Takes a string value and returns it with formatted keys as set in `format_type`
-    or `JSON_API_FORMAT_RELATED_LINKS`.
-
-    :format_type: Either 'dasherize', 'camelize', 'capitalize' or 'underscore'
-    """
-    if format_type is None:
-        format_type = json_api_settings.FORMAT_RELATED_LINKS
-
-    return format_value(value, format_type)
-
-
 def get_related_resource_type(relation):
     from rest_framework_json_api.serializers import PolymorphicModelSerializer
 
@@ -348,7 +403,7 @@ def format_drf_errors(response, context, exc):
     # handle all errors thrown from serializers
     else:
         for field, error in response.data.items():
-            field = format_value(field)
+            field = format_field_name(field)
             pointer = "/data/attributes/{}".format(field)
             if isinstance(exc, Http404) and isinstance(error, str):
                 # 404 errors don't have a pointer

rest_framework_json_api/views.py

@@ -25,9 +25,9 @@
 from rest_framework_json_api.utils import (
     Hyperlink,
     OrderedDict,
-    format_value,
     get_included_resources,
     get_resource_type_from_instance,
+    undo_format_link_segment,
 )
 
 
@@ -187,7 +187,7 @@ def get_related_serializer_class(self):
 
     def get_related_field_name(self):
         field_name = self.kwargs["related_field"]
-        return format_value(field_name, "underscore")
+        return undo_format_link_segment(field_name)
 
     def get_related_instance(self):
         parent_obj = self.get_object()

tests/test_parsers.py

@@ -29,7 +29,7 @@ def parser_context(self, rf):
     @pytest.mark.parametrize(
         "format_field_names",
         [
-            None,
+            False,
             "dasherize",
             "camelize",
             "capitalize",

tests/test_relations.py

@@ -233,7 +233,7 @@ def test_to_representation(self, model, field):
     @pytest.mark.parametrize(
         "format_related_links",
         [
-            None,
+            False,
             "dasherize",
             "camelize",
             "capitalize",

tests/test_utils.py

@@ -7,13 +7,17 @@
 
 from rest_framework_json_api import serializers
 from rest_framework_json_api.utils import (
+    format_field_name,
     format_field_names,
     format_link_segment,
     format_resource_type,
     format_value,
     get_included_serializers,
     get_related_resource_type,
     get_resource_name,
+    undo_format_field_name,
+    undo_format_field_names,
+    undo_format_link_segment,
 )
 from tests.models import (
     BasicModel,
@@ -176,6 +180,7 @@ def test_get_resource_name_with_errors(status_code):
 @pytest.mark.parametrize(
     "format_type,output",
     [
+        (False, {"full_name": {"last-name": "a", "first-name": "b"}}),
         ("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"}}),
@@ -192,22 +197,86 @@ def test_format_field_names(settings, format_type, output):
 @pytest.mark.parametrize(
     "format_type,output",
     [
-        (None, "first_Name"),
+        (False, {"fullName": "Test Name"}),
+        ("camelize", {"full_name": "Test Name"}),
+    ],
+)
+def test_undo_format_field_names(settings, format_type, output):
+    settings.JSON_API_FORMAT_FIELD_NAMES = format_type
+
+    value = {"fullName": "Test Name"}
+    assert undo_format_field_names(value) == output
+
+
+@pytest.mark.parametrize(
+    "format_type,output",
+    [
+        (False, "full_name"),
+        ("camelize", "fullName"),
+        ("capitalize", "FullName"),
+        ("dasherize", "full-name"),
+        ("underscore", "full_name"),
+    ],
+)
+def test_format_field_name(settings, format_type, output):
+    settings.JSON_API_FORMAT_FIELD_NAMES = format_type
+
+    field_name = "full_name"
+    assert format_field_name(field_name) == output
+
+
+@pytest.mark.parametrize(
+    "format_type,output",
+    [
+        (False, "fullName"),
+        ("camelize", "full_name"),
+    ],
+)
+def test_undo_format_field_name(settings, format_type, output):
+    settings.JSON_API_FORMAT_FIELD_NAMES = format_type
+
+    field_name = "fullName"
+    assert undo_format_field_name(field_name) == output
+
+
+@pytest.mark.parametrize(
+    "format_type,output",
+    [
+        (False, "first_Name"),
         ("camelize", "firstName"),
         ("capitalize", "FirstName"),
         ("dasherize", "first-name"),
         ("underscore", "first_name"),
     ],
 )
-def test_format_field_segment(settings, format_type, output):
+def test_format_link_segment(settings, format_type, output):
     settings.JSON_API_FORMAT_RELATED_LINKS = format_type
     assert format_link_segment("first_Name") == output
 
 
+def test_format_link_segment_deprecates_format_type_argument():
+    with pytest.deprecated_call():
+        assert "first-name" == format_link_segment("first_name", "dasherize")
+
+
+@pytest.mark.parametrize(
+    "format_links,output",
+    [
+        (False, "fullName"),
+        ("camelize", "full_name"),
+    ],
+)
+def test_undo_format_link_segment(settings, format_links, output):
+    settings.JSON_API_FORMAT_RELATED_LINKS = format_links
+
+    link_segment = "fullName"
+    assert undo_format_link_segment(link_segment) == output
+
+
 @pytest.mark.parametrize(
     "format_type,output",
     [
-        (None, "first_name"),
+        (False, "first_name"),
         ("camelize", "firstName"),
         ("capitalize", "FirstName"),
         ("dasherize", "first-name"),
@@ -218,6 +287,11 @@ def test_format_value(settings, format_type, output):
     assert format_value("first_name", format_type) == output
 
 
+def test_format_value_deprecates_default_format_type_argument():
+    with pytest.deprecated_call():
+        assert "first_name" == format_value("first_name")
+
+
 @pytest.mark.parametrize(
     "resource_type,pluralize,output",
     [

tests/test_views.py

@@ -8,7 +8,7 @@
 from rest_framework_json_api.parsers import JSONParser
 from rest_framework_json_api.relations import ResourceRelatedField
 from rest_framework_json_api.renderers import JSONRenderer
-from rest_framework_json_api.utils import format_value
+from rest_framework_json_api.utils import format_link_segment
 from rest_framework_json_api.views import ModelViewSet
 from tests.models import BasicModel
 
@@ -17,16 +17,18 @@ class TestModelViewSet:
     @pytest.mark.parametrize(
         "format_links",
         [
-            None,
+            False,
             "dasherize",
             "camelize",
             "capitalize",
             "underscore",
         ],
     )
     def test_get_related_field_name_handles_formatted_link_segments(
-        self, format_links, rf
+        self, settings, format_links, rf
     ):
+        settings.JSON_API_FORMAT_RELATED_LINKS = format_links
+
         # use field name which actually gets formatted
         related_model_field_name = "related_field_model"
 
@@ -43,7 +45,7 @@ class Meta:
         class RelatedFieldNameView(ModelViewSet):
             serializer_class = RelatedFieldNameSerializer
 
-        url_segment = format_value(related_model_field_name, format_links)
+        url_segment = format_link_segment(related_model_field_name)
 
         request = rf.get(f"/basic_models/1/{url_segment}")