test0908
/
django
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Set context.template instead of context.engine while rendering. 

This opens more possibilities, like accessing context.template.origin.

It also follows the chain of objects instead of following a shortcut.
This commit is contained in:
Aymeric Augustin 2015-02-17 22:49:59 +01:00
parent efb1f99f94
commit 1bfcc950ab
8 changed files with 53 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
django/template/base.py
View File

@ -204,19 +204,19 @@ class Template(object):
def render(self, context):
"Display stage -- can be called many times"
# Set engine attribute here to avoid changing the signature of either
# Context.__init__ or Node.render. The engine is set only on the first
# call to render. Further calls e.g. for includes don't override it.
toplevel_render = context.engine is None
# Set context.template to the original template -- as opposed to
# extended or included templates -- during rendering. This may be
# used for accessing context.template.engine.
toplevel_render = context.template is None
if toplevel_render:
context.engine = self.engine
context.template = self
context.render_context.push()
try:
return self._render(context)
finally:
context.render_context.pop()
if toplevel_render:
context.engine = None
context.template = None
class Token(object):
@ -655,7 +655,7 @@ class FilterExpression(object):
if ignore_failures:
obj = None
else:
string_if_invalid = context.engine.string_if_invalid
string_if_invalid = context.template.engine.string_if_invalid
if string_if_invalid:
if '%s' in string_if_invalid:
return string_if_invalid % self.var
@ -847,7 +847,7 @@ class Variable(object):
if getattr(current, 'do_not_call_in_templates', False):
pass
elif getattr(current, 'alters_data', False):
current = context.engine.string_if_invalid
current = context.template.engine.string_if_invalid
else:
try: # method call (assuming no args required)
current = current()
@ -855,12 +855,12 @@ class Variable(object):
try:
getcallargs(current)
except TypeError: # arguments *were* required
current = context.engine.string_if_invalid # invalid method call
current = context.template.engine.string_if_invalid # invalid method call
else:
raise
except Exception as e:
if getattr(e, 'silent_variable_failure', False):
current = context.engine.string_if_invalid
current = context.template.engine.string_if_invalid
else:
raise
@ -1257,9 +1257,9 @@ class Library(object):
elif isinstance(getattr(file_name, 'template', None), Template):
t = file_name.template
elif not isinstance(file_name, six.string_types) and is_iterable(file_name):
t = context.engine.select_template(file_name)
t = context.template.engine.select_template(file_name)
else:
t = context.engine.get_template(file_name)
t = context.template.engine.get_template(file_name)
self.nodelist = t.nodelist
new_context = context.new(_dict)
# Copy across the CSRF token, if present, because

30
django/template/context.py
View File

@ -123,7 +123,7 @@ class Context(BaseContext):
"A stack container for variable context"
def __init__(self, dict_=None, autoescape=True,
current_app=_current_app_undefined,
use_l10n=None, use_tz=None, engine=None):
use_l10n=None, use_tz=None):
if current_app is not _current_app_undefined:
warnings.warn(
"The current_app argument of Context is deprecated. Use "
@ -133,8 +133,10 @@ class Context(BaseContext):
self._current_app = current_app
self.use_l10n = use_l10n
self.use_tz = use_tz
self.engine = engine
self.render_context = RenderContext()
# Set to the original template during rendering -- as opposed to
# extended or included templates
self.template = None
super(Context, self).__init__(dict_)
@property
@ -192,11 +194,11 @@ class RequestContext(Context):
"""
def __init__(self, request, dict_=None, processors=None,
current_app=_current_app_undefined,
use_l10n=None, use_tz=None, engine=None):
use_l10n=None, use_tz=None):
# current_app isn't passed here to avoid triggering the deprecation
# warning in Context.__init__.
super(RequestContext, self).__init__(
dict_, use_l10n=use_l10n, use_tz=use_tz, engine=engine)
dict_, use_l10n=use_l10n, use_tz=use_tz)
if current_app is not _current_app_undefined:
warnings.warn(
"The current_app argument of RequestContext is deprecated. "
@ -207,23 +209,27 @@ class RequestContext(Context):
self._processors = () if processors is None else tuple(processors)
self._processors_index = len(self.dicts)
self.update({}) # placeholder for context processors output
self.engine = engine # re-run the setter in case engine is not None
@property
def engine(self):
return self._engine
def template(self):
return self._template
@engine.setter
def engine(self, engine):
self._engine = engine
@template.setter
def template(self, template):
# Execute context processors when Template.render(self, context) sets
# context.template = self. Until then, since the context isn't tied to
# an engine, it has no way to know which context processors to apply.
self._template = template
if hasattr(self, '_processors_index'):
if engine is None:
if template is None:
# Unset context processors.
self.dicts[self._processors_index] = {}
else:
# Set context processors for this engine.
processors = (template.engine.template_context_processors +
self._processors)
updates = {}
for processor in engine.template_context_processors + self._processors:
for processor in processors:
updates.update(processor(self.request))
self.dicts[self._processors_index] = updates

6
django/template/defaulttags.py
View File

@ -211,7 +211,7 @@ class ForNode(Node):
context[self.loopvars[0]] = item
# In debug mode provide the source of the node which raised
# the exception
if context.engine.debug:
if context.template.engine.debug:
for node in self.nodelist_loop:
try:
nodelist.append(node.render(context))
@ -392,7 +392,7 @@ class SsiNode(Node):
def render(self, context):
filepath = self.filepath.resolve(context)
if not include_is_allowed(filepath, context.engine.allowed_include_roots):
if not include_is_allowed(filepath, context.template.engine.allowed_include_roots):
if settings.DEBUG:
return "[Didn't have permission to include file]"
else:
@ -404,7 +404,7 @@ class SsiNode(Node):
output = ''
if self.parsed:
try:
t = Template(output, name=filepath, engine=context.engine)
t = Template(output, name=filepath, engine=context.template.engine)
return t.render(context)
except TemplateSyntaxError as e:
if settings.DEBUG:

6
django/template/loader_tags.py
View File

@ -107,7 +107,7 @@ class ExtendsNode(Node):
if isinstance(getattr(parent, 'template', None), Template):
# parent is a django.template.backends.django.Template
return parent.template
return context.engine.get_template(parent)
return context.template.engine.get_template(parent)
def render(self, context):
compiled_parent = self.get_parent(context)
@ -148,7 +148,7 @@ class IncludeNode(Node):
# Does this quack like a Template?
if not callable(getattr(template, 'render', None)):
# If not, we'll try get_template
template = context.engine.get_template(template)
template = context.template.engine.get_template(template)
values = {
name: var.resolve(context)
for name, var in six.iteritems(self.extra_context)
@ -158,7 +158,7 @@ class IncludeNode(Node):
with context.push(**values):
return template.render(context)
except Exception:
if context.engine.debug:
if context.template.engine.debug:
raise
return ''

2
django/templatetags/i18n.py
View File

@ -149,7 +149,7 @@ class BlockTranslateNode(Node):
result = translation.pgettext(message_context, singular)
else:
result = translation.ugettext(singular)
default_value = context.engine.string_if_invalid
default_value = context.template.engine.string_if_invalid
def render_value(key):
if key in context:

22
docs/howto/custom-template-tags.txt
View File

@ -756,10 +756,11 @@ Notes:
* The ``render()`` method is where the work actually happens.
* ``render()`` should generally fail silently, particularly in a production
environment. In some cases however, particularly if ``context.engine.debug``
is ``True``, this method may raise an exception to make debugging easier.
For example, several core tags raise ``django.template.TemplateSyntaxError``
if they receive the wrong number or type of arguments.
environment. In some cases however, particularly if
``context.template.engine.debug`` is ``True``, this method may raise an
exception to make debugging easier. For example, several core tags raise
``django.template.TemplateSyntaxError`` if they receive the wrong number or
type of arguments.
Ultimately, this decoupling of compilation and rendering results in an
efficient template system, because a template can render multiple contexts
@ -795,16 +796,17 @@ This is not a very common situation, but it's useful if you're rendering a
template yourself. For example::
def render(self, context):
t = context.engine.get_template('small_fragment.html')
t = context.template.engine.get_template('small_fragment.html')
return t.render(Context({'var': obj}, autoescape=context.autoescape))
.. versionchanged:: 1.8
The ``engine`` attribute of ``Context`` objects was added in Django 1.8.
:meth:`context.engine.get_template <django.template.Engine.get_template>`
must be used instead of :func:`django.template.loader.get_template`
because the latter now returns a wrapper whose ``render`` method doesn't
accept a :class:`~django.template.Context`.
The ``template`` attribute of ``Context`` objects was added in Django 1.8.
:meth:`context.template.engine.get_template
<django.template.Engine.get_template>` must be used instead of
:func:`django.template.loader.get_template` because the latter now returns
a wrapper whose ``render`` method doesn't accept a
:class:`~django.template.Context`.
If we had neglected to pass in the current ``context.autoescape`` value to our
new ``Context`` in this example, the results would have *always* been

4
docs/ref/templates/upgrading.txt
View File

@ -162,7 +162,7 @@ instance in the ``render()`` method of a template tag, you can use the current
You can write::
template = context.engine.get_template('included.html')
template = context.template.engine.get_template('included.html')
This will load the template with the current engine without triggering the
multiple template engines machinery, which is usually the desired behavior.
@ -201,7 +201,7 @@ APIs. The multiple template engines machinery isn't involved here.
Finally, if you have access to the current context, you can use the same trick
as above::
template = context.engine.from_string(template_code)
template = context.template.engine.from_string(template_code)
``Template()``
==============

7
tests/template_tests/tests.py
View File

@ -516,9 +516,6 @@ class RequestContextTests(unittest.TestCase):
self.assertEqual(len(ctx.dicts), 3)
def test_context_comparable(self):
# Create an engine without any context processors.
engine = Engine()
test_data = {'x': 'y', 'v': 'z', 'd': {'o': object, 'a': 'b'}}
# test comparing RequestContext to prevent problems if somebody
@ -526,8 +523,8 @@ class RequestContextTests(unittest.TestCase):
request = RequestFactory().get('/')
self.assertEqual(
RequestContext(request, dict_=test_data, engine=engine),
RequestContext(request, dict_=test_data, engine=engine))
RequestContext(request, dict_=test_data),
RequestContext(request, dict_=test_data))
@ignore_warnings(category=RemovedInDjango20Warning)