Refs django#10919 -- Refactored walk_items as module-level _walk_items and added truncated_unordered_list filter.

Author: rodbv

django/contrib/admin/templatetags/admin_filters.py

@@ -1,7 +1,10 @@
 from django import template
 from django.contrib.admin.options import EMPTY_VALUE_STRING
 from django.contrib.admin.utils import display_for_value
-from django.template.defaultfilters import stringfilter
+from django.template.defaultfilters import _walk_items, stringfilter
+from django.utils.html import conditional_escape
+from django.utils.safestring import mark_safe
+from django.utils.translation import ngettext
 
 register = template.Library()
 
@@ -10,3 +13,67 @@
 @stringfilter
 def to_object_display_value(value):
     return display_for_value(str(value), EMPTY_VALUE_STRING)
+
+
+@register.filter(is_safe=True, needs_autoescape=True)
+def truncated_unordered_list(value, max_items, autoescape=True):
+    """
+    Render an unordered list, showing at most ``max_items`` items and a
+    "...and N more objects." item at the end.
+
+    Usage::
+
+        {{ deleted_objects|truncated_unordered_list:100 }}
+    """
+
+    has_unlimited_items = max_items is None
+    if not has_unlimited_items:
+        max_items = int(max_items)
+        if max_items <= 0:
+            return mark_safe("")
+
+    if autoescape:
+        escaper = conditional_escape
+    else:
+
+        def escaper(x):
+            return x
+
+    item_count = 0
+
+    def list_formatter(item_list, tabs=1):
+        nonlocal item_count
+        indent = "\t" * tabs
+        output = []
+        for item, children in _walk_items(item_list):
+            sublist = ""
+            item_count += 1
+            should_display_item = has_unlimited_items or 0 < item_count <= max_items
+            if children:
+                sublist = "\n%s<ul>\n%s\n%s</ul>\n%s" % (
+                    indent,
+                    list_formatter(children, tabs + 1),
+                    indent,
+                    indent,
+                )
+
+            if should_display_item:
+                output.append("%s<li>%s%s</li>" % (indent, escaper(item), sublist))
+
+        return "\n".join(output)
+
+    rendered_object_list = list_formatter(value)
+    remaining_objects_message = ""
+
+    if not has_unlimited_items and item_count > max_items:
+        remaining_object_count = item_count - max_items
+        remaining_objects_message = "\n\t<li>%s</li>" % (
+            ngettext(
+                "…and %(count)d more object.",
+                "…and %(count)d more objects.",
+                remaining_object_count,
+            )
+            % {"count": remaining_object_count}
+        )
+
+    return mark_safe(rendered_object_list + remaining_objects_message)

django/template/defaultfilters.py

@@ -666,6 +666,31 @@ def slice_filter(value, arg):
         return value  # Fail silently.
 
 
+def _walk_items(item_list):
+    item_iterator = iter(item_list)
+    try:
+        item = next(item_iterator)
+        while True:
+            try:
+                next_item = next(item_iterator)
+            except StopIteration:
+                yield item, None
+                break
+            if isinstance(next_item, (list, tuple, types.GeneratorType)):
+                try:
+                    iter(next_item)
+                except TypeError:
+                    pass
+                else:
+                    yield item, next_item
+                    item = next(item_iterator)
+                    continue
+            yield item, None
+            item = next_item
+    except StopIteration:
+        pass
+
+
 @register.filter(is_safe=True, needs_autoescape=True)
 def unordered_list(value, autoescape=True):
     """
@@ -695,34 +720,10 @@ def unordered_list(value, autoescape=True):
         def escaper(x):
             return x
 
-    def walk_items(item_list):
-        item_iterator = iter(item_list)
-        try:
-            item = next(item_iterator)
-            while True:
-                try:
-                    next_item = next(item_iterator)
-                except StopIteration:
-                    yield item, None
-                    break
-                if isinstance(next_item, (list, tuple, types.GeneratorType)):
-                    try:
-                        iter(next_item)
-                    except TypeError:
-                        pass
-                    else:
-                        yield item, next_item
-                        item = next(item_iterator)
-                        continue
-                yield item, None
-                item = next_item
-        except StopIteration:
-            pass
-
     def list_formatter(item_list, tabs=1):
         indent = "\t" * tabs
         output = []
-        for item, children in walk_items(item_list):
+        for item, children in _walk_items(item_list):
             sublist = ""
             if children:
                 sublist = "\n%s<ul>\n%s\n%s</ul>\n%s" % (

tests/admin_views/test_templatetags.py

@@ -1,15 +1,17 @@
 import datetime
 import unittest
 
+from django import template
 from django.contrib.admin import ModelAdmin
+from django.contrib.admin.templatetags.admin_filters import truncated_unordered_list
 from django.contrib.admin.templatetags.admin_list import date_hierarchy
 from django.contrib.admin.templatetags.admin_modify import submit_row
 from django.contrib.admin.templatetags.base import InclusionAdminNode
 from django.contrib.auth import get_permission_codename
 from django.contrib.auth.admin import UserAdmin
 from django.contrib.auth.models import User
 from django.template.base import Token, TokenType
-from django.test import RequestFactory, TestCase
+from django.test import RequestFactory, SimpleTestCase, TestCase
 from django.urls import reverse
 from django.utils.version import PY314
 
@@ -18,6 +20,120 @@
 from .tests import AdminViewBasicTestCase, get_perm
 
 
+class TruncatedUnorderedListTests(SimpleTestCase):
+    def test_no_max_items(self):
+        result = truncated_unordered_list(["item 1", "item 2"], None)
+        self.assertEqual(result, ("\t<li>item 1</li>\n" "\t<li>item 2</li>"))
+        self.assertNotIn("more object", result)
+
+    def test_max_items_zero(self):
+        result = truncated_unordered_list(["a", "b", "c"], 0)
+        self.assertEqual(result, "")
+        self.assertNotIn("more object", result)
+
+    def test_flat_list_truncated(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", "b", "c", "d", "e"], 3),
+            (
+                "\t<li>a</li>\n"
+                "\t<li>b</li>\n"
+                "\t<li>c</li>\n"
+                "\t<li>…and 2 more objects.</li>"
+            ),
+        )
+
+    def test_nested_two_levels_truncated(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", ["a1", "a2"], "b", "c", "d", "e"], 3),
+            (
+                "\t<li>a\n"
+                "\t<ul>\n"
+                "\t\t<li>a1</li>\n"
+                "\t\t<li>a2</li>\n"
+                "\t</ul>\n"
+                "\t</li>\n"
+                "\t<li>…and 4 more objects.</li>"
+            ),
+        )
+
+    def test_nested_and_top_level_truncated(self):
+        self.assertEqual(
+            truncated_unordered_list(
+                ["a", ["n1", "n2", "n3", "n4", "n5"], "b", "c", "d", "e"],
+                3,
+            ),
+            (
+                "\t<li>a\n"
+                "\t<ul>\n"
+                "\t\t<li>n1</li>\n"
+                "\t\t<li>n2</li>\n"
+                "\t</ul>\n"
+                "\t</li>\n"
+                "\t<li>…and 7 more objects.</li>"
+            ),
+        )
+
+    def test_nested_three_levels_truncated(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", ["a1", ["a1x"]], "b", "c", "d", "e"], 3),
+            (
+                "\t<li>a\n"
+                "\t<ul>\n"
+                "\t\t<li>a1\n"
+                "\t\t<ul>\n"
+                "\t\t\t<li>a1x</li>\n"
+                "\t\t</ul>\n"
+                "\t\t</li>\n"
+                "\t</ul>\n"
+                "\t</li>\n"
+                "\t<li>…and 4 more objects.</li>"
+            ),
+        )
+
+    def test_max_items_equal_to_length(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", "b", "c"], 3),
+            ("\t<li>a</li>\n" "\t<li>b</li>\n" "\t<li>c</li>"),
+        )
+
+    def test_max_items_greater_than_length(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", "b"], 10),
+            ("\t<li>a</li>\n" "\t<li>b</li>"),
+        )
+
+    def test_truncated_single_remaining(self):
+        self.assertEqual(
+            truncated_unordered_list(["a", "b", "c"], 2),
+            ("\t<li>a</li>\n" "\t<li>b</li>\n" "\t<li>…and 1 more object.</li>"),
+        )
+
+    def test_autoescape(self):
+        self.assertEqual(
+            truncated_unordered_list(["<a>item</a>", "safe"], 1),
+            ("\t<li>&lt;a&gt;item&lt;/a&gt;</li>\n" "\t<li>…and 1 more object.</li>"),
+        )
+
+    def test_autoescape_off(self):
+        self.assertEqual(
+            truncated_unordered_list(["<a>item</a>", "safe"], 1, autoescape=False),
+            ("\t<li><a>item</a></li>\n" "\t<li>…and 1 more object.</li>"),
+        )
+
+    def test_empty_list(self):
+        self.assertEqual(truncated_unordered_list([], 5), "")
+
+    def test_template_rendering(self):
+        t = template.Template(
+            "{% load admin_filters %}{{ items|truncated_unordered_list:2 }}"
+        )
+        result = t.render(template.Context({"items": ["a", "b", "c"]}))
+        self.assertIn("<li>a</li>", result)
+        self.assertIn("<li>b</li>", result)
+        self.assertIn("<li>…and 1 more object.</li>", result)
+        self.assertNotIn("<li>c</li>", result)
+
+
 class AdminTemplateTagsTest(AdminViewBasicTestCase):
     request_factory = RequestFactory()
 

tests/template_tests/filter_tests/test_unordered_list.py

@@ -160,6 +160,19 @@ def item_generator():
             "<li>D</li>",
         )
 
+    def test_non_iterable_list_subclass(self):
+        class NonIterableList(list):
+            def __iter__(self):
+                raise TypeError
+
+            def __str__(self):
+                return "non-iterable-list"
+
+        self.assertEqual(
+            unordered_list(["A", NonIterableList(["x"]), "B"]),
+            "\t<li>A</li>\n\t<li>non-iterable-list</li>\n\t<li>B</li>",
+        )
+
     def test_ulitem_autoescape_off(self):
         class ULItem:
             def __init__(self, title):