mirror of https://github.com/zulip/zulip.git
102 lines
4.0 KiB
Python
102 lines
4.0 KiB
Python
from __future__ import absolute_import
|
|
|
|
import six
|
|
import sys
|
|
|
|
from typing import Any, Dict, List, Optional, Union, Text
|
|
if False:
|
|
from mypy_extensions import NoReturn
|
|
|
|
import jinja2
|
|
from django.test.signals import template_rendered
|
|
from django.template.backends import jinja2 as django_jinja2
|
|
from django.template import TemplateDoesNotExist, TemplateSyntaxError, Context
|
|
from django.utils.module_loading import import_string
|
|
from django.template.backends.utils import csrf_input_lazy, csrf_token_lazy
|
|
from django.http import HttpRequest
|
|
|
|
|
|
class Jinja2(django_jinja2.Jinja2):
|
|
"""Context processors aware Jinja2 backend.
|
|
|
|
The default Jinja2 backend in Django is not aware of context
|
|
processors so we just derive from the default Jinja2 backend
|
|
and add the functionality to pass the context processors to
|
|
the `Template` object.
|
|
"""
|
|
|
|
def __init__(self, params, *args, **kwargs):
|
|
# type: (Dict[str, Any], *Any, **Any) -> None
|
|
# We need to remove `context_processors` from `OPTIONS` because
|
|
# `Environment` doesn't expect it
|
|
context_processors = params['OPTIONS'].pop('context_processors', [])
|
|
debug = params['OPTIONS'].pop('debug', False)
|
|
super(Jinja2, self).__init__(params, *args, **kwargs)
|
|
|
|
# We need to create these two properties after calling the __init__
|
|
# of base class so that they are not overridden.
|
|
self.context_processors = context_processors
|
|
self.debug = debug
|
|
|
|
def get_template(self, template_name):
|
|
# type: (str) -> Template
|
|
try:
|
|
return Template(self.env.get_template(template_name), self)
|
|
except jinja2.TemplateNotFound as exc:
|
|
six.reraise(TemplateDoesNotExist, TemplateDoesNotExist(exc.args),
|
|
sys.exc_info()[2])
|
|
except jinja2.TemplateSyntaxError as exc:
|
|
six.reraise(TemplateSyntaxError, TemplateSyntaxError(exc.args),
|
|
sys.exc_info()[2])
|
|
|
|
def from_string(self, template_code):
|
|
# type: (str) -> Template
|
|
return Template(self.env.from_string(template_code), self)
|
|
|
|
|
|
class Template(django_jinja2.Template):
|
|
"""Context processors aware Template.
|
|
|
|
This class upgrades the default `Template` to apply context
|
|
processors to the context before passing it to the `render`
|
|
function.
|
|
"""
|
|
def __init__(self, template, backend):
|
|
# type: (django_jinja2.Template, django_jinja2.BaseEngine) -> None
|
|
# TODO: Remove this function once we shift to Django 1.11 completely.
|
|
# This is only intended for backward compatibility.
|
|
self.template = template
|
|
self.backend = backend
|
|
self.origin = django_jinja2.Origin(
|
|
name=template.filename, template_name=template.name,
|
|
)
|
|
|
|
def render(self, context=None, request=None):
|
|
# type: (Optional[Union[Dict[str, Any], Context]], Optional[HttpRequest]) -> Text
|
|
if context is None:
|
|
context = {}
|
|
|
|
if isinstance(context, Context):
|
|
# Jinja2 expects a dictionary
|
|
# This condition makes sure that `flatten` is called only when
|
|
# `context` is an instance of `Context`.
|
|
#
|
|
# Note: If we don't ignore then mypy complains about missing
|
|
# `flatten` attribute in some members of union.
|
|
context = context.flatten() # type: ignore
|
|
|
|
if request is not None:
|
|
context['request'] = request
|
|
context['csrf_input'] = csrf_input_lazy(request)
|
|
context['csrf_token'] = csrf_token_lazy(request)
|
|
|
|
for context_processor in self.backend.context_processors:
|
|
cp = import_string(context_processor)
|
|
context.update(cp(request))
|
|
|
|
if self.backend.debug:
|
|
template_rendered.send(sender=self, template=self,
|
|
context=context)
|
|
|
|
return self.template.render(context)
|