Added TEMPLATE_STRING_IF_INVALID setting, which specifies what the template system should output in case of invalid variables. Default is empty string (to match current behavior)

git-svn-id: http://code.djangoproject.com/svn/django/trunk@2294 bcc190cf-cafb-0310-a4f2-bffc1f526a37

5 files changed, 50 insertions, 15 deletions

diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
index 048504a5c8..0b9d377573 100644
--- a/django/conf/global_settings.py
+++ b/django/conf/global_settings.py
@@ -113,6 +113,9 @@ TEMPLATE_CONTEXT_PROCESSORS = (
 #    'django.core.context_processors.request',
 )
 
+# Output to use in template system for invalid (e.g. misspelled) variables.
+TEMPLATE_STRING_IF_INVALID = ''
+
 # URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
 # trailing slash.
 # Examples: "http://foo.com/media/", "/media/".
diff --git a/django/core/template/__init__.py b/django/core/template/__init__.py
index 6298ce24b9..fe1a9cb338 100644
--- a/django/core/template/__init__.py
+++ b/django/core/template/__init__.py
@@ -57,7 +57,7 @@ times with multiple contexts)
 import re
 from inspect import getargspec
 from django.utils.functional import curry
-from django.conf.settings import DEFAULT_CHARSET, TEMPLATE_DEBUG
+from django.conf.settings import DEFAULT_CHARSET, TEMPLATE_DEBUG, TEMPLATE_STRING_IF_INVALID
 
 __all__ = ('Template','Context','compile_string')
 
@@ -181,7 +181,7 @@ class Context:
         for dict in self.dicts:
             if dict.has_key(key):
                 return dict[key]
-        return ''
+        return TEMPLATE_STRING_IF_INVALID
 
     def __delitem__(self, key):
         "Delete a variable from the current context"
@@ -588,7 +588,7 @@ class FilterExpression(object):
         try:
             obj = resolve_variable(self.var, context)
         except VariableDoesNotExist:
-            obj = ''
+            obj = TEMPLATE_STRING_IF_INVALID
         for func, args in self.filters:
             arg_vals = []
             for lookup, arg in args:
@@ -657,7 +657,7 @@ def resolve_variable(path, context):
         try:
            current = number_type(path)
         except ValueError:
-           current = ''
+           current = TEMPLATE_STRING_IF_INVALID
     elif path[0] in ('"', "'") and path[0] == path[-1]:
         current = path[1:-1]
     else:
@@ -671,16 +671,16 @@ def resolve_variable(path, context):
                     current = getattr(current, bits[0])
                     if callable(current):
                         if getattr(current, 'alters_data', False):
-                            current = ''
+                            current = TEMPLATE_STRING_IF_INVALID
                         else:
                             try: # method call (assuming no args required)
                                 current = current()
                             except SilentVariableFailure:
-                                current = ''
+                                current = TEMPLATE_STRING_IF_INVALID
                             except TypeError: # arguments *were* required
                                 # GOTCHA: This will also catch any TypeError
                                 # raised in the function itself.
-                                current = '' # invalid method call
+                                current = TEMPLATE_STRING_IF_INVALID # invalid method call
                 except (TypeError, AttributeError):
                     try: # list-index lookup
                         current = current[int(bits[0])]
diff --git a/docs/settings.txt b/docs/settings.txt
index 3f83ea0e69..bf333da1b8 100644
--- a/docs/settings.txt
+++ b/docs/settings.txt
@@ -621,6 +621,18 @@ Default: ``('django.core.template.loaders.filesystem.load_template_source',)``
 A tuple of callables (as strings) that know how to import templates from
 various sources. See the `template documentation`_.
 
+TEMPLATE_STRING_IF_INVALID
+--------------------------
+
+Default: ``''`` (Empty string)
+
+**New in Django development version.**
+
+Output, as a string, that the template system should use for invalid (e.g.
+misspelled) variables. See `How invalid variables are handled`_.
+
+.. _How invalid variables are handled: http://www.djangoproject.com/documentation/templates_python/#how-invalid-variables-are-handled
+
 TIME_FORMAT
 -----------
 
diff --git a/docs/templates.txt b/docs/templates.txt
index 20fe62bbae..d210ec2f77 100644
--- a/docs/templates.txt
+++ b/docs/templates.txt
@@ -70,6 +70,12 @@ Use a dot (``.``) to access attributes of a variable.
 In the above example, ``{{ section.title }}`` will be replaced with the
 ``title`` attribute of the ``section`` object.
 
+In Django 0.91, if you use a variable that doesn't exist, it will be silently
+ignored; the variable will be replaced by nothingness. In the Django
+development version, if a variable doesn't exist, the template system inserts
+the value of the ``TEMPLATE_STRING_IF_INVALID`` setting, which is set to ``''``
+(the empty string) by default.
+
 If you use a variable that doesn't exist, it will be silently ignored. The
 variable will be replaced by nothingness.
 
diff --git a/docs/templates_python.txt b/docs/templates_python.txt
index efbd648cf1..9203b92f9c 100644
--- a/docs/templates_python.txt
+++ b/docs/templates_python.txt
@@ -135,14 +135,6 @@ Here are a few examples::
     >>> t.render(c)
     "The first stooge in the list is Larry."
 
-If a variable doesn't exist, the template system fails silently. The variable
-is replaced with an empty string::
-
-    >>> t = Template("My name is {{ my_name }}.")
-    >>> c = Context({"foo": "bar"})
-    >>> t.render(c)
-    "My name is ."
-
 Method lookups are slightly more complex than the other lookup types. Here are
 some things to keep in mind:
 
@@ -193,6 +185,28 @@ some things to keep in mind:
             self.database_record.delete()
         sensitive_function.alters_data = True
 
+How invalid variables are handled
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In Django 0.91, if a variable doesn't exist, the template system fails
+silently. The variable is replaced with an empty string::
+
+    >>> t = Template("My name is {{ my_name }}.")
+    >>> c = Context({"foo": "bar"})
+    >>> t.render(c)
+    "My name is ."
+
+This applies to any level of lookup::
+
+    >>> t = Template("My name is {{ person.fname }} {{ person.lname }}.")
+    >>> c = Context({"person": {"fname": "Stan"}})
+    >>> t.render(c)
+    "My name is Stan ."
+
+In the Django development version, if a variable doesn't exist, the template
+system inserts the value of the ``TEMPLATE_STRING_IF_INVALID`` setting, which
+is set to ``''`` (the empty string) by default.
+
 Playing with Context objects
 ----------------------------