Ticket #9874: template-cache.diff

django/conf/global_settings.py

@@ -171 +171 @@
 # Output to use in template system for invalid (e.g. misspelled) variables.
 TEMPLATE_STRING_IF_INVALID = ''
 
+# Whether to cache compiled templates in global memory. This setting has no
+# effect when TEMPLATE_DEBUG is enabled.
+TEMPLATE_CACHE = False
+
 # URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
 # trailing slash.
 # Examples: "http://foo.com/media/", "/media/".

django/template/loader.py

@@ -24 +24 @@
 from django.template import Origin, Template, Context, TemplateDoesNotExist, add_to_builtins
 from django.utils.importlib import import_module
 from django.conf import settings
+from threading import Lock
 
 template_source_loaders = None
 
+cache_lock = Lock()
+template_cache = {}
+
 class LoaderOrigin(Origin):
     def __init__(self, display_name, loader, name, dirs):
         super(LoaderOrigin, self).__init__(display_name)
@@ -73 +77 @@
             pass
     raise TemplateDoesNotExist, name
 
-def get_template(template_name):
+def get_template(template_name, dirs=None):
     """
     Returns a compiled Template object for the given template name,
     handling template inheritance recursively.
+
+    The compiled template may be cached for future speedy lookup.
     """
-    source, origin = find_template_source(template_name)
-    template = get_template_from_string(source, origin, template_name)
+    global cache_lock, template_cache
+
+    def get_new_template(template_name, dirs):
+        source, origin = find_template_source(template_name, dirs)
+        return get_template_from_string(source, origin, template_name)
+
+    if isinstance(dirs, list):
+        dirs = tuple(dirs)
+
+    if settings.TEMPLATE_DEBUG or (not settings.TEMPLATE_CACHE):
+        template = get_new_template(template_name, dirs)
+    else:
+        cache_lock.acquire()
+        try:
+            try:
+                template = template_cache[(template_name, dirs)]
+            except KeyError:
+                template = get_new_template(template_name, dirs)
+                template_cache[(template_name, dirs)] = template
+        finally:
+            cache_lock.release()
+
     return template
 
 def get_template_from_string(source, origin=None, name=None):

django/template/loader_tags.py

@@ -1 +1 @@
 from django.template import TemplateSyntaxError, TemplateDoesNotExist, Variable
 from django.template import Library, Node, TextNode
-from django.template.loader import get_template, get_template_from_string, find_template_source
+from django.template.loader import get_template
 from django.conf import settings
 from django.utils.safestring import mark_safe
 
@@ -61 +61 @@
         if hasattr(parent, 'render'):
             return parent # parent is a Template object
         try:
-            source, origin = find_template_source(parent, self.template_dirs)
+            parent_template = get_template(parent, self.template_dirs)
         except TemplateDoesNotExist:
-            raise TemplateSyntaxError, "Template %r cannot be extended, because it doesn't exist" % parent
-        else:
-            return get_template_from_string(source, origin, parent)
+            raise TemplateSyntaxError, "Template '%r' cannot be extended, because it doesn't exist" % parent
+        return parent_template
 
     def render(self, context):
         compiled_parent = self.get_parent(context)

docs/ref/settings.txt

@@ -1051 +1051 @@
 A tuple of callables (as strings) that know how to import templates from
 various sources. See :ref:`ref-templates-api`.
 
+.. setting:: TEMPLATE_GLOBAL_CACHE
+
+TEMPLATE_CACHE
+---------------------
+
+Default: ``False``
+
+A boolean that turns on/off the template cache. If this is ``True`` and
+``TEMPLATE_DEBUG`` is not enabled, templates will be loaded, compiled, and
+the compiled form cached for future requests. This is a speed optimization.
+
+You will need to restart your server if you change a template with this
+setting enabled and ``TEMPLATE_DEBUG`` dissabled.
+
+Templates are cached in memory. Do not enable this if you have a template
+loader which could load a potentially unbounded number of templates, say
+from a database.
+
+See also ``TEMPLATE_DEBUG``.
+
 .. setting:: TEMPLATE_STRING_IF_INVALID
 
 TEMPLATE_STRING_IF_INVALID

tests/regressiontests/templates/loaders.py

@@ -89 +89 @@
         settings.INSTALLED_APPS = []
         self.assertRaises(TemplateDoesNotExist, lts_egg, "y.html")
 
+
+from django.template.loader import template_cache, get_template
+
+class CachedLoaders(unittest.TestCase):
+    def setUp(self):
+        global template_cache
+        template_cache.clear()
+        self._template_cache = settings.TEMPLATE_CACHE
+        self._template_debug = settings.TEMPLATE_DEBUG
+
+    def tearDown(self):
+        settings.TEMPLATE_CACHE = self._template_cache
+        settings.TEMPLATE_DEBUG = self._template_debug
+
+    def test_enabled(self):
+        "Load a template with caching enabled and debug dissabled"
+        settings.TEMPLATE_DEBUG = False
+        settings.TEMPLATE_CACHE = True
+        global template_cache
+        self.assertEqual(len(template_cache), 0)
+        t = get_template("base.html")
+        t = get_template("base.html")
+        self.assertEqual(len(template_cache), 1)
+        template_name, dirs = template_cache.keys()[0]
+        self.assertEqual(template_name, "base.html")
+        self.assertEqual(dirs, None)
+
+    def test_disabled(self):
+        "Load a template with caching dissabled"
+        settings.TEMPLATE_CACHE = False
+        settings.TEMPLATE_DEBUG = False
+        global template_cache
+        self.assertEqual(len(template_cache), 0)
+        t = get_template("base.html")
+        t = get_template("base.html")
+        self.assertEqual(len(template_cache), 0)
+
+    def test_debug(self):
+        "Load a template with caching dissabled by debugging"
+        settings.TEMPLATE_CACHE = True
+        settings.TEMPLATE_DEBUG = True
+        global template_cache
+        self.assertEqual(len(template_cache), 0)
+        t = get_template("base.html")
+        t = get_template("base.html")
+        self.assertEqual(len(template_cache), 0)
+
+
 if __name__ == "__main__":
     unittest.main()