Refactored renderer, updated parser, added error handling to return

proper error response. Renamed package to json api.

Author: Eric Honkanen

example/__init__.py

@@ -0,0 +1,66 @@
+from django.contrib.auth import models as auth_models
+from rest_framework import viewsets, generics, renderers, parsers
+from rest_framework.decorators import list_route, detail_route
+from rest_framework.response import Response
+from rest_framework_ember import mixins, utils
+from ..serializers.identity import IdentitySerializer
+from ..serializers.post import PostSerializer
+
+
+class Identity(mixins.MultipleIDMixin, viewsets.ModelViewSet):
+    queryset = auth_models.User.objects.all()
+    serializer_class = IdentitySerializer
+
+    @list_route()
+    def empty_list(self, request):
+        """
+        This is a hack/workaround to return an empty result on a list
+        endpoint because the delete operation in the test_empty_pluralization
+        test doesn't prevent the /identities endpoint from still returning
+        records when called in the same test. Suggestions welcome.
+        """
+        self.queryset = self.queryset.filter(pk=None)
+        return super(Identity, self).list(request)
+
+    # demonstrate sideloading data for use at app boot time
+    @list_route()
+    def posts(self, request):
+        self.resource_name = False
+
+        identities = self.queryset
+        posts = [{'id': 1, 'title': 'Test Blog Post'}]
+
+        data = {
+            u'identities': IdentitySerializer(identities, many=True).data,
+            u'posts': PostSerializer(posts, many=True).data,
+        }
+        return Response(utils.format_keys(data, format_type='camelize'))
+
+    @detail_route()
+    def manual_resource_name(self, request, *args, **kwargs):
+        self.resource_name = 'data'
+        return super(Identity, self).retrieve(request, args, kwargs)
+
+
+class GenericIdentity(generics.GenericAPIView):
+    """
+    An endpoint that uses DRF's default format so we can test that.
+
+    GET /identities/generic
+    """
+    serializer_class = IdentitySerializer
+    allowed_methods = ['GET']
+    renderer_classes = (renderers.JSONRenderer, )
+    parser_classes = (parsers.JSONParser, )
+
+
+    def get_queryset(self):
+        return auth_models.User.objects.all()
+
+    def get(self, request, pk=None):
+        """
+        GET request
+        """
+        obj = self.get_object()
+        return Response(IdentitySerializer(obj).data)
+

example/api/__init__.py

@@ -0,0 +1,13 @@
+from django.contrib.auth import models as auth_models
+from rest_framework import serializers
+
+
+class IdentitySerializer(serializers.ModelSerializer):
+    """
+    Identity Serializer
+    """
+    class Meta:
+        model = auth_models.User
+        fields = (
+            'id', 'first_name', 'last_name', 'email', )
+

example/api/resources/__init__.py

@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+
+class PostSerializer(serializers.Serializer):
+    """
+    Blog post serializer
+    """
+    title = serializers.CharField(max_length=50)
+

example/api/resources/identity.py

@@ -0,0 +1,42 @@
+
+from django.contrib.auth import get_user_model
+from rest_framework.test import APITestCase
+
+
+class TestBase(APITestCase):
+    """
+    Test base class to setup a couple users.
+    """
+    def setUp(self):
+        """
+        Create those users
+        """
+        super(TestBase, self).setUp()
+        self.create_users()
+
+    def create_user(self, username, email, password="pw",
+                     first_name='', last_name=''):
+        """
+        Helper method to create a user
+        """
+        User = get_user_model()
+        user = User.objects.create_user(
+            username, email, password=password
+        )
+        if first_name or last_name:
+            user.first_name = first_name
+            user.last_name = last_name
+            user.save()
+        return user
+
+    def create_users(self):
+        """
+        Create a couple users
+        """
+        self.john = self.create_user(
+            'trane', '[email protected]',
+            first_name='John', last_name="Coltrane")
+        self.miles = self.create_user(
+            'miles', '[email protected]',
+            first_name="Miles", last_name="Davis")
+

example/api/serializers/__init__.py

@@ -2,9 +2,8 @@
 Parsers
 """
 from rest_framework import parsers
-from rest_framework_ember.utils import get_resource_name
 
-from .utils import format_keys
+from . import utils
 
 
 class JSONParser(parsers.JSONParser):
@@ -28,13 +27,5 @@ def parse(self, stream, media_type=None, parser_context=None):
         """
         result = super(JSONParser, self).parse(stream, media_type=media_type,
                                                parser_context=parser_context)
-        resource = result.get(get_resource_name(parser_context.get('view', None)))
-        return format_keys(resource, 'underscore')
-
-
-class EmberJSONParser(JSONParser):
-    """
-    Backward compatability for our first uniquely named parser
-    """
-    pass
-
+        resource = result.get(utils.get_resource_name(parser_context))
+        return utils.format_keys(resource, 'underscore')

example/api/serializers/identity.py

@@ -2,9 +2,8 @@
 Renderers
 """
 from rest_framework import renderers
-from rest_framework_ember.utils import get_resource_name
 
-from .utils import format_keys, format_resource_name
+from . import utils
 
 
 class JSONRenderer(renderers.JSONRenderer):
@@ -20,27 +19,43 @@ class JSONRenderer(renderers.JSONRenderer):
     }
     """
     def render(self, data, accepted_media_type=None, renderer_context=None):
-        view = renderer_context.get('view')
-        resource_name = get_resource_name(view)
+        # Get the resource name.
+        resource_name = utils.get_resource_name(view)
 
-        if resource_name == False:
+        # If no `resource_name` is found, render the default response.
+        if not resource_name:
             return super(JSONRenderer, self).render(
-                data, accepted_media_type, renderer_context)
+                data, accepted_media_type, renderer_context
+            )
 
-        data = format_keys(data, 'camelize')
-
-        try:
-            content = data.pop('results')
-            resource_name = format_resource_name(content, resource_name)
-            data = {resource_name : content, "meta" : data}
-        except (TypeError, KeyError, AttributeError) as e:
-
-            # Default behavior
-            if not resource_name == 'data':
-                format_keys(data, 'camelize')
-                resource_name = format_resource_name(data, resource_name)
-
-            data = {resource_name : data}
+        # If this is an error response, skip the rest.
+        if 'errors' in resource_name or resource_name == 'data':
+            return super(JSONRenderer, self).render(
+                {resource_name: data}, accepted_media_type, renderer_context
+            )
+
+        # Camelize the keynames.
+        formatted_data = utils.format_keys(data, 'camelize')
+
+        # Check if it's paginated data and contains a `results` key.
+        results = (formatted_data.get('results')
+                   if isinstance(formatted_data, dict) else None)
+
+        # Pluralize the resource_name.
+        resource_name = utils.format_resource_name(
+            results or formatted_data, resource_name
+        )
+
+        if results:
+            rendered_data = {
+                resource_name: results,
+                'meta': formatted_data
+            }
+        else:
+            rendered_data = {
+                resource_name: formatted_data
+            }
 
         return super(JSONRenderer, self).render(
-            data, accepted_media_type, renderer_context)
+            rendered_data, accepted_media_type, renderer_context
+        )

example/api/serializers/post.py

@@ -3,19 +3,38 @@
 """
 import inflection
 
+from rest_framework.exceptions import APIException
+
 from django.conf import settings
 from django.utils import six
+from django.utils.translation import ugettext_lazy as _
 
 try:
     from rest_framework.compat import OrderedDict
 except ImportError:
     OrderedDict = dict
 
 
-def get_resource_name(view):
+def get_resource_name(context):
     """
     Return the name of a resource.
     """
+    view = context.get('view')
+
+    # Sanity check to make sure we have a view.
+    if not view:
+        raise APIException(_('Could not find view.'))
+
+    # Check to see if there is a status code and return early
+    # with the resource_name value of `errors`.
+    try:
+        code = str(view.response.status_code)
+    except (AttributeError, ValueError):
+        pass
+    else:
+        if code.startswith('4') or code.startswith('5'):
+            return 'errors'
+
     try:
         # Check the view
         resource_name = getattr(view, 'resource_name')
@@ -75,7 +94,7 @@ def format_resource_name(obj, name):
     """
     Pluralize the resource name if more than one object in results.
     """
-    if (getattr(settings, 'REST_EMBER_PLURALIZE_KEYS', False)
+    if (getattr(settings, 'REST_EMBER_PLURALIZE_KEYS')
             and isinstance(obj, list)):
 
         return inflection.pluralize(name)