PLAT-1419 Make edxmako a proper template backend

cms/djangoapps/contentstore/views/helpers.py

@@ -44,11 +44,11 @@ def event(request):
     return HttpResponse(status=204)
 
 
-def render_from_lms(template_name, dictionary, context=None, namespace='main'):
+def render_from_lms(template_name, dictionary, namespace='main'):
     """
-    Render a template using the LMS MAKO_TEMPLATES
+    Render a template using the LMS Mako templates
     """
-    return render_to_string(template_name, dictionary, context, namespace="lms." + namespace)
+    return render_to_string(template_name, dictionary, namespace="lms." + namespace)
 
 
 def get_parent_xblock(xblock):

cms/envs/common.py

@@ -119,7 +119,7 @@
     VIDEO_TRANSCRIPTS_SETTINGS,
 
     # Methods to derive settings
-    _make_main_mako_templates,
+    _make_mako_template_dirs,
     _make_locale_paths,
 )
 from path import Path as path
@@ -134,7 +134,7 @@
     get_theme_base_dirs_from_settings
 )
 from openedx.core.lib.license import LicenseMixin
-from openedx.core.lib.derived import derived, derived_dict_entry
+from openedx.core.lib.derived import derived, derived_collection_entry
 from openedx.core.release import doc_version
 
 ############################ FEATURE CONFIGURATION #############################
@@ -310,11 +310,9 @@
 
 ############################# TEMPLATE CONFIGURATION #############################
 # Mako templating
-# TODO: Move the Mako templating into a different engine in TEMPLATES below.
 import tempfile
 MAKO_MODULE_DIR = os.path.join(tempfile.gettempdir(), 'mako_cms')
-MAKO_TEMPLATES = {}
-MAIN_MAKO_TEMPLATES_BASE = [
+MAKO_TEMPLATE_DIRS_BASE = [
     PROJECT_ROOT / 'templates',
     COMMON_ROOT / 'templates',
     COMMON_ROOT / 'djangoapps' / 'pipeline_mako' / 'templates',
@@ -324,19 +322,27 @@
     OPENEDX_ROOT / 'core' / 'lib' / 'license' / 'templates',
     CMS_ROOT / 'djangoapps' / 'pipeline_js' / 'templates',
 ]
-MAKO_TEMPLATES['lms.main'] = lms.envs.common.MAIN_MAKO_TEMPLATES_BASE
 
-MAKO_TEMPLATES['main'] = _make_main_mako_templates
-derived_dict_entry('MAKO_TEMPLATES', 'main')
+CONTEXT_PROCESSORS = (
+    'django.template.context_processors.request',
+    'django.template.context_processors.static',
+    'django.contrib.messages.context_processors.messages',
+    'django.template.context_processors.i18n',
+    'django.contrib.auth.context_processors.auth',  # this is required for admin
+    'django.template.context_processors.csrf',
+    'dealer.contrib.django.staff.context_processor',  # access git revision
+    'help_tokens.context_processor',
+)
 
 # Django templating
 TEMPLATES = [
     {
+        'NAME': 'django',
         'BACKEND': 'django.template.backends.django.DjangoTemplates',
         # Don't look for template source files inside installed applications.
         'APP_DIRS': False,
         # Instead, look for template source files in these dirs.
-        'DIRS': MAIN_MAKO_TEMPLATES_BASE,
+        'DIRS': _make_mako_template_dirs,
         # Options specific to this backend.
         'OPTIONS': {
             'loaders': (
@@ -346,21 +352,36 @@
                 'edxmako.makoloader.MakoFilesystemLoader',
                 'edxmako.makoloader.MakoAppDirectoriesLoader',
             ),
-            'context_processors': (
-                'django.template.context_processors.request',
-                'django.template.context_processors.static',
-                'django.contrib.messages.context_processors.messages',
-                'django.template.context_processors.i18n',
-                'django.contrib.auth.context_processors.auth',  # this is required for admin
-                'django.template.context_processors.csrf',
-                'dealer.contrib.django.staff.context_processor',  # access git revision
-                'help_tokens.context_processor',
-            ),
+            'context_processors': CONTEXT_PROCESSORS,
             # Change 'debug' in your environment settings files - not here.
             'debug': False
         }
-    }
+    },
+    {
+        'NAME': 'mako',
+        'BACKEND': 'edxmako.backend.Mako',
+        'APP_DIRS': False,
+        'DIRS': _make_mako_template_dirs,
+        'OPTIONS': {
+            'context_processors': CONTEXT_PROCESSORS,
+            'debug': False,
+        }
+    },
+    {
+        # This separate copy of the Mako backend is used to render previews using the LMS templates
+        'NAME': 'preview',
+        'BACKEND': 'edxmako.backend.Mako',
+        'APP_DIRS': False,
+        'DIRS': lms.envs.common.MAKO_TEMPLATE_DIRS_BASE,
+        'OPTIONS': {
+            'context_processors': CONTEXT_PROCESSORS,
+            'debug': False,
+            'namespace': 'lms.main',
+        }
+    },
 ]
+derived_collection_entry('TEMPLATES', 0, 'DIRS')
+derived_collection_entry('TEMPLATES', 1, 'DIRS')
 DEFAULT_TEMPLATE_ENGINE = TEMPLATES[0]
 
 ##############################################################################

common/djangoapps/edxmako/__init__.py

@@ -14,3 +14,13 @@
 LOOKUP = {}
 
 from .paths import add_lookup, lookup_template, clear_lookups, save_lookups
+
+
+class Engines(object):
+    """
+    Aliases for the available template engines.
+    Note that the preview engine is only configured for cms.
+    """
+    DJANGO = 'django'
+    MAKO = 'mako'
+    PREVIEW = 'preview'

common/djangoapps/edxmako/apps.py

@@ -20,8 +20,11 @@ def ready(self):
         IMPORTANT: This method can be called multiple times during application startup. Any changes to this method
         must be safe for multiple callers during startup phase.
         """
-        template_locations = settings.MAKO_TEMPLATES
-        for namespace, directories in template_locations.items():
+        for backend in settings.TEMPLATES:
+            if 'edxmako' not in backend['BACKEND']:
+                continue
+            namespace = backend['OPTIONS'].get('namespace', 'main')
+            directories = backend['DIRS']
             clear_lookups(namespace)
             for directory in directories:
                 add_lookup(namespace, directory)

common/djangoapps/edxmako/backend.py

@@ -0,0 +1,67 @@
+"""
+Django template system engine for Mako templates.
+"""
+from __future__ import absolute_import, unicode_literals
+
+import logging
+
+from django.template import TemplateDoesNotExist, TemplateSyntaxError
+from django.template.backends.base import BaseEngine
+from django.template.context import _builtin_context_processors
+from django.utils.functional import cached_property
+from django.utils.module_loading import import_string
+from mako.exceptions import MakoException, TopLevelLookupException, text_error_template
+
+from openedx.core.djangoapps.theming.helpers import get_template_path
+
+from .paths import lookup_template
+from .template import Template
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Mako(BaseEngine):
+    """
+    A Mako template engine to be added to the ``TEMPLATES`` Django setting.
+    """
+    app_dirname = 'templates'
+
+    def __init__(self, params):
+        """
+        Fetches template options, initializing BaseEngine properties,
+        and assigning our Mako default settings.
+        Note that OPTIONS contains backend-specific settings.
+        :param params: This is simply the template dict you
+                       define in your settings file.
+        """
+        params = params.copy()
+        options = params.pop('OPTIONS').copy()
+        super(Mako, self).__init__(params)
+        self.context_processors = options.pop('context_processors', [])
+        self.namespace = options.pop('namespace', 'main')
+
+    def from_string(self, template_code):
+        try:
+            return Template(template_code)
+        except MakoException:
+            message = text_error_template().render()
+            raise TemplateSyntaxError(message)
+
+    def get_template(self, template_name):
+        """
+        Loads and returns a template for the given name.
+        """
+        template_name = get_template_path(template_name)
+        try:
+            return Template(lookup_template(self.namespace, template_name), engine=self)
+        except TopLevelLookupException:
+            raise TemplateDoesNotExist(template_name)
+
+    @cached_property
+    def template_context_processors(self):
+        """
+        Collect and cache the active context processors.
+        """
+        context_processors = _builtin_context_processors
+        context_processors += tuple(self.context_processors)
+        return tuple(import_string(path) for path in context_processors)

common/djangoapps/edxmako/makoloader.py

@@ -2,7 +2,7 @@
 
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
-from django.template import Engine
+from django.template import Engine, engines
 from django.template.base import TemplateDoesNotExist
 from django.template.loaders.app_directories import Loader as AppDirectoriesLoader
 from django.template.loaders.filesystem import Loader as FilesystemLoader
@@ -16,8 +16,8 @@
 class MakoLoader(object):
     """
     This is a Django loader object which will load the template as a
-    Mako template if the first line is "## mako". It is based off BaseLoader
-    in django.template.loader.
+    Mako template if the first line is "## mako". It is based off Loader
+    in django.template.loaders.base.
     We need this in order to be able to include mako templates inside main_django.html.
     """
 
@@ -53,7 +53,8 @@ def load_template(self, template_name, template_dirs=None):
                                 output_encoding='utf-8',
                                 default_filters=['decode.utf8'],
                                 encoding_errors='replace',
-                                uri=template_name)
+                                uri=template_name,
+                                engine=engines['mako'])
             return template, None
         else:
             # This is a regular template

common/djangoapps/edxmako/request_context.py

@@ -20,24 +20,12 @@
 
 
 from crum import get_current_request
-from django.conf import settings
 from django.template import RequestContext
-from django.template.context import _builtin_context_processors
-from django.utils.module_loading import import_string
 
 import request_cache
 from util.request import safe_get_host
 
 
-def get_template_context_processors():
-    """
-    Returns the context processors defined in settings.TEMPLATES.
-    """
-    context_processors = _builtin_context_processors
-    context_processors += tuple(settings.DEFAULT_TEMPLATE_ENGINE['OPTIONS']['context_processors'])
-    return tuple(import_string(path) for path in context_processors)
-
-
 def get_template_request_context(request=None):
     """
     Returns the template processing context to use for the current request,
@@ -60,13 +48,6 @@ def get_template_request_context(request=None):
     context['is_secure'] = request.is_secure()
     context['site'] = safe_get_host(request)
 
-    # This used to happen when a RequestContext object was initialized but was
-    # moved to a different part of the logic when template engines were introduced.
-    # Since we are not using template engines we do this here.
-    # https://github.com/django/django/commit/37505b6397058bcc3460f23d48a7de9641cd6ef0
-    for processor in get_template_context_processors():
-        context.update(processor(request))
-
     request_cache_dict[cache_key] = context
 
     return context

common/djangoapps/edxmako/shortcuts.py

@@ -18,12 +18,12 @@
 from django.conf import settings
 from django.core.urlresolvers import reverse
 from django.http import HttpResponse
-from django.template import Context
+from django.template import engines
 
-from edxmako import lookup_template
-from edxmako.request_context import get_template_request_context
 from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
-from openedx.core.djangoapps.theming.helpers import get_template_path, is_request_in_themed_site
+from openedx.core.djangoapps.theming.helpers import is_request_in_themed_site
+
+from . import Engines
 
 log = logging.getLogger(__name__)
 
@@ -131,7 +131,7 @@ def footer_context_processor(request):  # pylint: disable=unused-argument
     )
 
 
-def render_to_string(template_name, dictionary, context=None, namespace='main', request=None):
+def render_to_string(template_name, dictionary, namespace='main', request=None):
     """
     Render a Mako template to as a string.
 
@@ -147,52 +147,23 @@ def render_to_string(template_name, dictionary, context=None, namespace='main',
             from the template paths specified in configuration.
         dictionary: A dictionary of variables to insert into the template during
             rendering.
-        context: A :class:`~django.template.Context` with values to make
-            available to the template.
         namespace: The Mako namespace to find the named template in.
         request: The request to use to construct the RequestContext for rendering
             this template. If not supplied, the current request will be used.
     """
+    if namespace == 'lms.main':
+        engine = engines[Engines.PREVIEW]
+    else:
+        engine = engines[Engines.MAKO]
+    template = engine.get_template(template_name)
+    return template.render(dictionary, request)
+
 
-    template_name = get_template_path(template_name)
-
-    context_instance = Context(dictionary)
-    # add dictionary to context_instance
-    context_instance.update(dictionary or {})
-    # collapse context_instance to a single dictionary for mako
-    context_dictionary = {}
-    context_instance['settings'] = settings
-    context_instance['EDX_ROOT_URL'] = settings.EDX_ROOT_URL
-    context_instance['marketing_link'] = marketing_link
-    context_instance['is_any_marketing_link_set'] = is_any_marketing_link_set
-    context_instance['is_marketing_link_set'] = is_marketing_link_set
-
-    # In various testing contexts, there might not be a current request context.
-    request_context = get_template_request_context(request)
-    if request_context:
-        for item in request_context:
-            context_dictionary.update(item)
-    for item in context_instance:
-        context_dictionary.update(item)
-    if context:
-        context_dictionary.update(context)
-
-    # "Fix" CSRF token by evaluating the lazy object
-    KEY_CSRF_TOKENS = ('csrf_token', 'csrf')
-    for key in KEY_CSRF_TOKENS:
-        if key in context_dictionary:
-            context_dictionary[key] = unicode(context_dictionary[key])
-
-    # fetch and render template
-    template = lookup_template(namespace, template_name)
-    return template.render_unicode(**context_dictionary)
-
-
-def render_to_response(template_name, dictionary=None, context_instance=None, namespace='main', request=None, **kwargs):
+def render_to_response(template_name, dictionary=None, namespace='main', request=None, **kwargs):
     """
     Returns a HttpResponse whose content is filled with the result of calling
     lookup.get_template(args[0]).render with the passed arguments.
     """
 
     dictionary = dictionary or {}
-    return HttpResponse(render_to_string(template_name, dictionary, context_instance, namespace, request), **kwargs)
+    return HttpResponse(render_to_string(template_name, dictionary, namespace, request), **kwargs)