Allow `./` and `../` in paths when recursively including templates

[Gabriel Nick Pivovarov]

Hi. Currently, when trying to recursively include a Django template within itself using the include tag with a path that contains ./ or ../, Django raises a TemplateSyntaxError. However, using a path that does not contain ./ or ../ does not raise the error. When the error is raised, the debug toolbar describes it like this:

TemplateSyntaxError at /

The relative path ‘“./ul.html”’ was translated to template name ‘app/ul.html’, the same template in which the tag appears.

Here is an example of a template in a Django app called app with the path app/templates/app/ul.html that would produce the error given above:

<ul>
    {% for section in sections %}
        <li>
            <p>{{ section.name }}</p>
            {% if section.sections|length != 0 %}
                {% include "./ul.html" with sections=section.sections %}
            {% endif %}
        </li>
    {% endfor %}
</ul>

However, replacing the directory ./ul.html with the equivalent app/ul.html makes the error go away (assuming that the project's settings.py specifies APP_DIRS = True and the views and URLs are configured correctly). The actual paths are translated identically in both cases, and the behavior of the include tag should not depend simply on whether or not the path string uses ./ or ../ (or if it should, this is not documented in the Django documentation). Therefore, it seems that this is a bug. The expected behavior is that an error is only raised when recursively using the extends template, not when recursively using the include template.

Contrapositively, it appears that recursively extending a template using the extends tag with a path that does not contain ./ or ../ raises a TemplateDoesNotExist exception.

One possible fix is to modify the django/template/loader_tags.py file (​https://github.com/django/django/blob/main/django/template/loader_tags.py) such that the error is raised when a template attempts to extend itself (not when a template attempts to include itself, which would otherwise be valid). The error handling logic in question starts on line 267 of that file within the construct_relative_path function; perhaps it should only be used when called from the do_extends function.

Here is a relevant discussion in the Django forums: ​https://forum.djangoproject.com/t/template-recursion-why-does-django-not-allow-and/31689

[Sarah Boyce]

Relative path support was added in #26402 and recursive include support was added in #3544.
I think this was missed when working on #26402, replicated. Here is my test:

tests/template_tests/syntax_tests/test_include.py

@@ -339 +339 @@
             .replace("\n", " ")
             .strip(),
         )
+        t = engine.get_template("recursive_relative_include.html")
+        self.assertEqual(
+            "Recursion!  A1  Recursion!  B1   B2   B3  Recursion!  C1",
+            t.render(Context({"comments": comments}))
+            .replace(" ", "")
+            .replace("\n", " ")
+            .strip(),
+        )
 
     def test_include_cache(self):
         """

tests/template_tests/templates/recursive_relative_include.html

@@ +1 @@
+Recursion!
+{% for comment in comments %}
+    {{ comment.comment }}
+    {% if comment.children %}
+        {% include "./recursive_relative_include.html" with comments=comment.children %}
+    {% endif %}
+{% endfor %}