Merge branch 'feature/refactor_view' into develop

Author: Fantomas42

docs/index.rst

@@ -715,29 +715,26 @@ Generic views
 The ``tagging.views`` module contains views to handle simple cases of
 common display logic related to tagging.
 
-``tagging.views.tagged_object_list``
-------------------------------------
+``tagging.views.TaggedObjectList``
+----------------------------------
 
 **Description:**
 
 A view that displays a list of objects for a given model which have a
 given tag. This is a thin wrapper around the
-``django.views.generic.list_detail.object_list`` view, which takes a
+``django.views.generic.list.ListView`` view, which takes a
 model and a tag as its arguments (in addition to the other optional
-arguments supported by ``object_list``), building the appropriate
+arguments supported by ``ListView``), building the appropriate
 ``QuerySet`` for you instead of expecting one to be passed in.
 
 **Required arguments:**
 
-   * ``queryset_or_model``: A ``QuerySet`` or Django model class for the
-     object which will be listed.
-
    * ``tag``: The tag which objects of the given model must have in
      order to be listed.
 
 **Optional arguments:**
 
-Please refer to the `object_list documentation`_ for additional optional
+Please refer to the `ListView documentation`_ for additional optional
 arguments which may be given.
 
    * ``related_tags``: If ``True``, a ``related_tags`` context variable
@@ -751,12 +748,12 @@ arguments which may be given.
 
 **Template context:**
 
-Please refer to the `object_list documentation`_ for  additional
+Please refer to the `ListView documentation`_ for  additional
 template context variables which may be provided.
 
    * ``tag``: The ``Tag`` instance for the given tag.
 
-.. _`object_list documentation`: http://docs.djangoproject.com/en/dev/ref/generic-views/#django-views-generic-list-detail-object-list
+.. _`ListView documentation`: https://docs.djangoproject.com/en/1.8/ref/class-based-views/generic-display/#listview
 
 Example usage
 ~~~~~~~~~~~~~
@@ -766,15 +763,13 @@ list items of a particular model class which have a given tag::
 
    from django.conf.urls.defaults import *
 
-   from tagging.views import tagged_object_list
+   from tagging.views import TaggedObjectList
 
    from shop.apps.products.models import Widget
 
    urlpatterns = patterns('',
-       url(r'^widgets/tag/(?P<tag>[^/]+)/$',
-           tagged_object_list,
-           dict(queryset_or_model=Widget, paginate_by=10, allow_empty=True,
-                template_object_name='widget'),
+       url(r'^widgets/tag/(?P<tag>[^/]+(?u))/$',
+           TaggedObjectList.as_view(model=Widget, paginate_by=10, allow_empty=True),
            name='widget_tag_detail'),
    )
 
@@ -783,13 +778,10 @@ perform filtering of the objects which are listed::
 
    from myapp.models import People
 
-   from tagging.views import tagged_object_list
+   from tagging.views import TaggedObjectList
 
-   def tagged_people(request, country_code, tag):
+   class TaggedPeopleFilteredList(TaggedObjectList):
        queryset = People.objects.filter(country__code=country_code)
-       return tagged_object_list(request, queryset, tag, paginate_by=25,
-           allow_empty=True, template_object_name='people')
-
 
 Template tags
 =============

tagging/tests/tests.py

@@ -7,6 +7,8 @@
 from django.utils import six
 from django.db.models import Q
 from django.test import TestCase
+from django.test.utils import override_settings
+from django.core.exceptions import ImproperlyConfigured
 
 from tagging import settings
 from tagging.forms import TagField
@@ -1031,3 +1033,61 @@ def test_tag_d_validation(self):
         self.assertRaises(
             forms.ValidationError, t.clean,
             'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar')
+
+
+#########
+# Views #
+#########
+
+
+@override_settings(
+    ROOT_URLCONF='tagging.tests.urls',
+    TEMPLATE_LOADERS=(
+        'tagging.tests.utils.VoidLoader',
+    ),
+)
+class TestTaggedObjectList(TestCase):
+
+    def setUp(self):
+        self.a1 = Article.objects.create(name='article 1')
+        self.a2 = Article.objects.create(name='article 2')
+        Tag.objects.update_tags(self.a1, 'static tag test')
+        Tag.objects.update_tags(self.a2, 'static test')
+
+    def get_view(self, url, queries=1, code=200,
+                 expected_items=1,
+                 friendly_context='article_list',
+                 template='tests/article_list.html'):
+        with self.assertNumQueries(queries):
+            response = self.client.get(url)
+        self.assertEquals(response.status_code, code)
+
+        if code == 200:
+            self.assertTrue(isinstance(response.context['tag'], Tag))
+            self.assertEqual(len(response.context['object_list']),
+                             expected_items)
+            self.assertEqual(response.context['object_list'],
+                             response.context[friendly_context])
+            self.assertTemplateUsed(response, template)
+        return response
+
+    def test_view_static(self):
+        self.get_view('/static/', expected_items=2)
+
+    def test_view_dynamic(self):
+        self.get_view('/tag/', expected_items=1)
+
+    def test_view_related(self):
+        response = self.get_view('/static/related/',
+                                 queries=2, expected_items=2)
+        self.assertEquals(len(response.context['related_tags']), 2)
+
+    def test_view_no_queryset_no_model(self):
+        self.assertRaises(ImproperlyConfigured, self.get_view,
+                          '/no-query-no-model/')
+
+    def test_view_no_tag(self):
+        self.assertRaises(AttributeError, self.get_view, '/no-tag/')
+
+    def test_view_404(self):
+        self.get_view('/unavailable/', code=404)

tagging/tests/urls.py

@@ -0,0 +1,20 @@
+"""Test urls for tagging."""
+from django.conf.urls import url
+
+from tagging.views import TaggedObjectList
+from tagging.tests.models import Article
+
+
+class StaticTaggedObjectList(TaggedObjectList):
+    tag = 'static'
+    queryset = Article.objects.all()
+
+
+urlpatterns = [
+    url(r'^static/$', StaticTaggedObjectList.as_view()),
+    url(r'^static/related/$', StaticTaggedObjectList.as_view(
+        related_tags=True)),
+    url(r'^no-tag/$', TaggedObjectList.as_view(model=Article)),
+    url(r'^no-query-no-model/$', TaggedObjectList.as_view()),
+    url(r'^(?P<tag>[^/]+(?u))/$', TaggedObjectList.as_view(model=Article)),
+]

tagging/tests/utils.py

@@ -0,0 +1,16 @@
+"""
+Tests utils for tagging.
+"""
+
+from django.template.loader import BaseLoader
+
+class VoidLoader(BaseLoader):
+    """
+    Template loader which is always returning
+    an empty template.
+    """
+    is_usable = True
+    _accepts_engine_in_init = True
+
+    def load_template_source(self, template_name, template_dirs=None):
+        return ('', 'voidloader:%s' % template_name)

tagging/views.py

@@ -2,19 +2,20 @@
 Tagging related views.
 """
 from django.http import Http404
+from django.views.generic.list import ListView
 from django.utils.translation import ugettext as _
-from django.views.generic.list_detail import object_list
+from django.core.exceptions import ImproperlyConfigured
 
 from tagging.models import Tag
 from tagging.models import TaggedItem
 from tagging.utils import get_tag
+from tagging.utils import get_queryset_and_model
 
 
-def tagged_object_list(request, queryset_or_model=None, tag=None,
-                       related_tags=False, related_tag_counts=True, **kwargs):
+class TaggedObjectList(ListView):
     """
     A thin wrapper around
-    ``django.views.generic.list_detail.object_list`` which creates a
+    ``django.views.generic.list.ListView`` which creates a
     ``QuerySet`` containing instances of the given queryset or model
     tagged with the given tag.
 
@@ -28,30 +29,50 @@ def tagged_object_list(request, queryset_or_model=None, tag=None,
     tag will have a ``count`` attribute indicating the number of items
     which have it in addition to the given tag.
     """
-    if queryset_or_model is None:
-        try:
-            queryset_or_model = kwargs.pop('queryset_or_model')
-        except KeyError:
-            raise AttributeError(
-                _('tagged_object_list must be called '
-                  'with a queryset or a model.'))
-
-    if tag is None:
-        try:
-            tag = kwargs.pop('tag')
-        except KeyError:
-            raise AttributeError(
-                _('tagged_object_list must be called with a tag.'))
-
-    tag_instance = get_tag(tag)
-    if tag_instance is None:
-        raise Http404(_('No Tag found matching "%s".') % tag)
-    queryset = TaggedItem.objects.get_by_model(queryset_or_model, tag_instance)
-    if 'extra_context' not in kwargs:
-        kwargs['extra_context'] = {}
-    kwargs['extra_context']['tag'] = tag_instance
-    if related_tags:
-        kwargs['extra_context']['related_tags'] = \
-            Tag.objects.related_for_model(tag_instance, queryset_or_model,
-                                          counts=related_tag_counts)
-    return object_list(request, queryset, **kwargs)
+    tag = None
+    related_tags = False
+    related_tag_counts = True
+
+    def get_tag(self):
+        if self.tag is None:
+            try:
+                self.tag = self.kwargs.pop('tag')
+            except KeyError:
+                raise AttributeError(
+                    _('TaggedObjectList must be called with a tag.'))
+
+        tag_instance = get_tag(self.tag)
+        if tag_instance is None:
+            raise Http404(_('No Tag found matching "%s".') % self.tag)
+
+        return tag_instance
+
+    def get_queryset_or_model(self):
+        if self.queryset is not None:
+            return self.queryset
+        elif self.model is not None:
+            return self.model
+        else:
+            raise ImproperlyConfigured(
+                "%(cls)s is missing a QuerySet. Define "
+                "%(cls)s.model, %(cls)s.queryset, or override "
+                "%(cls)s.get_queryset_or_model()." % {
+                    'cls': self.__class__.__name__
+                }
+            )
+
+    def get_queryset(self):
+        self.queryset_or_model = self.get_queryset_or_model()
+        self.tag_instance = self.get_tag()
+        return TaggedItem.objects.get_by_model(
+            self.queryset_or_model, self.tag_instance)
+
+    def get_context_data(self, **kwargs):
+        context = super(TaggedObjectList, self).get_context_data(**kwargs)
+        context['tag'] = self.tag_instance
+
+        if self.related_tags:
+            queryset, model = get_queryset_and_model(self.queryset_or_model)
+            context['related_tags'] = Tag.objects.related_for_model(
+                self.tag_instance, model, counts=self.related_tag_counts)
+        return context