path: root/ext/django2jinja/django2jinja.py

# -*- coding: utf-8 -*-
"""
Django to Jinja
~~~~~~~~~~~~~~~

Helper module that can convert django templates into Jinja templates.

This file is not intended to be used as stand alone application but to
be used as library.  To convert templates you basically create your own
writer, add extra conversion logic for your custom template tags,
configure your django environment and run the `convert_templates`
function.

Here a simple example::

    # configure django (or use settings.configure)
    import os

    os.environ["DJANGO_SETTINGS_MODULE"] = "yourapplication.settings"
    from yourapplication.foo.templatetags.bar import MyNode

    from django2jinja import Writer, convert_templates

    def write_my_node(writer, node):
        writer.start_variable()
        writer.write("myfunc(")
        for idx, arg in enumerate(node.args):
            if idx:
                writer.write(", ")
            writer.node(arg)
        writer.write(")")
        writer.end_variable()

    writer = Writer()
    writer.node_handlers[MyNode] = write_my_node
    convert_templates("/path/to/output/folder", writer=writer)

Here is an example hos to automatically translate your django
variables to jinja2::

    import re
    # List of tuple (Match pattern, Replace pattern, Exclusion pattern)
    var_re = (
        (re.compile("(u|user)\\.is_authenticated"), "\\1.is_authenticated()", None),
        (re.compile("\\.non_field_errors"), ".non_field_errors()", None),
        (re.compile("\\.label_tag"), ".label_tag()", None),
        (re.compile("\\.as_dl"), ".as_dl()", None),
        (re.compile("\\.as_table"), ".as_table()", None),
        (re.compile("\\.as_widget"), ".as_widget()", None),
        (re.compile("\\.as_hidden"), ".as_hidden()", None),
        (re.compile("\\.get_([0-9_\\w]+)_url"), ".get_\\1_url()", None),
        (re.compile("\\.url"), ".url()", re.compile("(form|calendar).url")),
        (re.compile("\\.get_([0-9_\\w]+)_display"), ".get_\\1_display()", None),
        (re.compile("loop\\.counte"), "loop.index", None),
        (re.compile("loop\\.revcounte"), "loop.revindex", None),
        (
            re.compile("request\\.GET\\.([0-9_\\w]+)"),
            "request.GET.get('\\1', '')",
            None,
        ),
        (re.compile("request\\.get_host"), "request.get_host()", None),
        (re.compile("\\.all(?!_)"), ".all()", None),
        (re.compile("\\.all\\.0"), ".all()[0]", None),
        (re.compile("\\.([0-9])($|\\s+)"), "[\\1]\\2", None),
        (re.compile("\\.items"), ".items()", None),
    )
    writer = Writer(var_re=var_re)

For details about the writing process have a look at the module code.

:copyright: (c) 2009 by the Jinja Team.
:license: BSD.
"""
from __future__ import print_function

import os
import re
import sys

from django.conf import settings
from django.template import defaulttags as core_tags
from django.template import FilterExpression
from django.template import libraries
from django.template import loader
from django.template import loader_tags
from django.template import TextNode
from django.template import TOKEN_TEXT
from django.template import TOKEN_VAR
from django.template import Variable
from django.template.debug import DebugVariableNode as VariableNode
from django.templatetags import i18n as i18n_tags

from jinja2 import defaults

_node_handlers = {}
_resolved_filters = {}
_newline_re = re.compile(r"(?:\r\n|\r|\n)")

# Django stores an itertools object on the cycle node.  Not only is this
# thread unsafe but also a problem for the converter which needs the raw
# string values passed to the constructor to create a jinja loop.cycle()
# call from it.
_old_cycle_init = core_tags.CycleNode.__init__


def _fixed_cycle_init(self, cyclevars, variable_name=None):
    self.raw_cycle_vars = map(Variable, cyclevars)
    _old_cycle_init(self, cyclevars, variable_name)


core_tags.CycleNode.__init__ = _fixed_cycle_init


def node(cls):
    def proxy(f):
        _node_handlers[cls] = f
        return f

    return proxy


def convert_templates(
    output_dir, extensions=(".html", ".txt"), writer=None, callback=None
):
    """Iterates over all templates in the template dirs configured and
    translates them and writes the new templates into the output
    directory.
    """
    if writer is None:
        writer = Writer()

    def filter_templates(files):
        for filename in files:
            ifilename = filename.lower()
            for extension in extensions:
                if ifilename.endswith(extension):
                    yield filename

    def translate(f, loadname):
        template = loader.get_template(loadname)
        original = writer.stream
        writer.stream = f
        writer.body(template.nodelist)
        writer.stream = original

    if callback is None:

        def callback(template):
            print(template)

    for directory in settings.TEMPLATE_DIRS:
        for dirname, _, files in os.walk(directory):
            dirname = dirname[len(directory) + 1 :]
            for filename in filter_templates(files):
                source = os.path.normpath(os.path.join(dirname, filename))
                target = os.path.join(output_dir, dirname, filename)
                basetarget = os.path.dirname(target)
                if not os.path.exists(basetarget):
                    os.makedirs(basetarget)
                callback(source)
                with open(target, "w") as f:
                    translate(f, source)


class Writer(object):
    """The core writer class."""

    def __init__(
        self,
        stream=None,
        error_stream=None,
        block_start_string=defaults.BLOCK_START_STRING,
        block_end_string=defaults.BLOCK_END_STRING,
        variable_start_string=defaults.VARIABLE_START_STRING,
        variable_end_string=defaults.VARIABLE_END_STRING,
        comment_start_string=defaults.COMMENT_START_STRING,
        comment_end_string=defaults.COMMENT_END_STRING,
        initial_autoescape=True,
        use_jinja_autoescape=False,
        custom_node_handlers=None,
        var_re=None,
        env=None,
    ):
        if stream is None:
            stream = sys.stdout
        if error_stream is None:
            error_stream = sys.stderr
        self.stream = stream
        self.error_stream = error_stream
        self.block_start_string = block_start_string
        self.block_end_string = block_end_string
        self.variable_start_string = variable_start_string
        self.variable_end_string = variable_end_string
        self.comment_start_string = comment_start_string
        self.comment_end_string = comment_end_string
        self.autoescape = initial_autoescape
        self.spaceless = False
        self.use_jinja_autoescape = use_jinja_autoescape
        self.node_handlers = dict(_node_handlers, **(custom_node_handlers or {}))
        self._loop_depth = 0
        self._filters_warned = set()
        self.var_re = [] if var_re is None else var_re
        self.env = env

    def enter_loop(self):
        """Increments the loop depth so that write functions know if
        they are in a loop.
        """
        self._loop_depth += 1

    def leave_loop(self):
        """Reverse of enter_loop."""
        self._loop_depth -= 1

    @property
    def in_loop(self):
        """True if we are in a loop."""
        return self._loop_depth > 0

    def write(self, s):
        """Writes stuff to the stream."""
        self.stream.write(s.encode(settings.FILE_CHARSET))

    def print_expr(self, expr):
        """Open a variable tag, write to the string to the stream and
        close.
        """
        self.start_variable()
        self.write(expr)
        self.end_variable()

    def _post_open(self):
        if self.spaceless:
            self.write("- ")
        else:
            self.write(" ")

    def _pre_close(self):
        if self.spaceless:
            self.write(" -")
        else:
            self.write(" ")

    def start_variable(self):
        """Start a variable."""
        self.write(self.variable_start_string)
        self._post_open()

    def end_variable(self, always_safe=False):
        """End a variable."""
        if not always_safe and self.autoescape and not self.use_jinja_autoescape:
            self.write("|e")
        self._pre_close()
        self.write(self.variable_end_string)

    def start_block(self):
        """Starts a block."""
        self.write(self.block_start_string)
        self._post_open()

    def end_block(self):
        """Ends a block."""
        self._pre_close()
        self.write(self.block_end_string)

    def tag(self, name):
        """Like `print_expr` just for blocks."""
        self.start_block()
        self.write(name)
        self.end_block()

    def variable(self, name):
        """Prints a variable. This performs variable name
        transformation.
        """
        self.write(self.translate_variable_name(name))

    def literal(self, value):
        """Writes a value as literal."""
        value = repr(value)
        if value[:2] in ('u"', "u'"):
            value = value[1:]
        self.write(value)

    def filters(self, filters, is_block=False):
        """Dumps a list of filters."""
        want_pipe = not is_block
        for filter, args in filters:
            name = self.get_filter_name(filter)
            if name is None:
                self.warn("Could not find filter %s" % name)
                continue
            if (
                name not in defaults.DEFAULT_FILTERS
                and name not in self._filters_warned
            ):
                self._filters_warned.add(name)
                self.warn("Filter %s probably doesn't exist in Jinja" % name)
            if not want_pipe:
                want_pipe = True
            else:
                self.write("|")
            self.write(name)
            if args:
                self.write("(")
                for idx, (is_var, value) in enumerate(args):
                    if idx:
                        self.write(", ")
                    if is_var:
                        self.node(value)
                    else:
                        self.literal(value)
                self.write(")")

    def get_location(self, origin, position):
        """Returns the location for an origin and position tuple as name
        and lineno.
        """
        if hasattr(origin, "source"):
            source = origin.source
            name = "<unknown source>"
        else:
            source = origin.loader(origin.loadname, origin.dirs)[0]
            name = origin.loadname
        lineno = len(_newline_re.findall(source[: position[0]])) + 1
        return name, lineno

    def warn(self, message, node=None):
        """Prints a warning to the error stream."""
        if node is not None and hasattr(node, "source"):
            filename, lineno = self.get_location(*node.source)
            message = "[%s:%d] %s" % (filename, lineno, message)
        print(message, file=self.error_stream)

    def translate_variable_name(self, var):
        """Performs variable name translation."""
        if self.in_loop and var == "forloop" or var.startswith("forloop."):
            var = var[3:]

        for reg, rep, unless in self.var_re:
            no_unless = unless and unless.search(var) or True
            if reg.search(var) and no_unless:
                var = reg.sub(rep, var)
                break
        return var

    def get_filter_name(self, filter):
        """Returns the filter name for a filter function or `None` if there
        is no such filter.
        """
        if filter not in _resolved_filters:
            for library in libraries.values():
                for key, value in library.filters.items():
                    _resolved_filters[value] = key
        return _resolved_filters.get(filter, None)

    def node(self, node):
        """Invokes the node handler for a node."""
        for cls, handler in self.node_handlers.items():
            if type(node) is cls or type(node).__name__ == cls:
                handler(self, node)
                break
        else:
            self.warn(
                "Untranslatable node %s.%s found"
                % (node.__module__, node.__class__.__name__),
                node,
            )

    def body(self, nodes):
        """Calls node() for every node in the iterable passed."""
        for node in nodes:
            self.node(node)


@node(TextNode)
def text_node(writer, node):
    writer.write(node.s)


@node(Variable)
def variable(writer, node):
    if node.translate:
        writer.warn("i18n system used, make sure to install translations", node)
        writer.write("_(")
    if node.literal is not None:
        writer.literal(node.literal)
    else:
        writer.variable(node.var)
    if node.translate:
        writer.write(")")


@node(VariableNode)
def variable_node(writer, node):
    writer.start_variable()
    if (
        node.filter_expression.var.var == "block.super"
        and not node.filter_expression.filters
    ):
        writer.write("super()")
    else:
        writer.node(node.filter_expression)
    writer.end_variable()


@node(FilterExpression)
def filter_expression(writer, node):
    writer.node(node.var)
    writer.filters(node.filters)


@node(core_tags.CommentNode)
def comment_tag(writer, node):
    pass


@node(core_tags.DebugNode)
def debug_tag(writer, node):
    writer.warn(
        "Debug tag detected.  Make sure to add a global function "
        "called debug to the namespace.",
        node=node,
    )
    writer.print_expr("debug()")


@node(core_tags.ForNode)
def for_loop(writer, node):
    writer.start_block()
    writer.write("for ")
    for idx, var in enumerate(node.loopvars):
        if idx:
            writer.write(", ")
        writer.variable(var)
    writer.write(" in ")
    if node.is_reversed:
        writer.write("(")
    writer.node(node.sequence)
    if node.is_reversed:
        writer.write(")|reverse")
    writer.end_block()
    writer.enter_loop()
    writer.body(node.nodelist_loop)
    writer.leave_loop()
    writer.tag("endfor")


@node(core_tags.IfNode)
def if_condition(writer, node):
    writer.start_block()
    writer.write("if ")
    join_with = "and"
    if node.link_type == core_tags.IfNode.LinkTypes.or_:
        join_with = "or"

    for idx, (ifnot, expr) in enumerate(node.bool_exprs):
        if idx:
            writer.write(" %s " % join_with)
        if ifnot:
            writer.write("not ")
        writer.node(expr)
    writer.end_block()
    writer.body(node.nodelist_true)
    if node.nodelist_false:
        writer.tag("else")
        writer.body(node.nodelist_false)
    writer.tag("endif")


@node(core_tags.IfEqualNode)
def if_equal(writer, node):
    writer.start_block()
    writer.write("if ")
    writer.node(node.var1)
    if node.negate:
        writer.write(" != ")
    else:
        writer.write(" == ")
    writer.node(node.var2)
    writer.end_block()
    writer.body(node.nodelist_true)
    if node.nodelist_false:
        writer.tag("else")
        writer.body(node.nodelist_false)
    writer.tag("endif")


@node(loader_tags.BlockNode)
def block(writer, node):
    writer.tag("block " + node.name.replace("-", "_").rstrip("_"))
    node = node
    while node.parent is not None:
        node = node.parent
    writer.body(node.nodelist)
    writer.tag("endblock")


@node(loader_tags.ExtendsNode)
def extends(writer, node):
    writer.start_block()
    writer.write("extends ")
    if node.parent_name_expr:
        writer.node(node.parent_name_expr)
    else:
        writer.literal(node.parent_name)
    writer.end_block()
    writer.body(node.nodelist)


@node(loader_tags.ConstantIncludeNode)
@node(loader_tags.IncludeNode)
def include(writer, node):
    writer.start_block()
    writer.write("include ")
    if hasattr(node, "template"):
        writer.literal(node.template.name)
    else:
        writer.node(node.template_name)
    writer.end_block()


@node(core_tags.CycleNode)
def cycle(writer, node):
    if not writer.in_loop:
        writer.warn("Untranslatable free cycle (cycle outside loop)", node=node)
        return
    if node.variable_name is not None:
        writer.start_block()
        writer.write("set %s = " % node.variable_name)
    else:
        writer.start_variable()
    writer.write("loop.cycle(")
    for idx, var in enumerate(node.raw_cycle_vars):
        if idx:
            writer.write(", ")
        writer.node(var)
    writer.write(")")
    if node.variable_name is not None:
        writer.end_block()
    else:
        writer.end_variable()


@node(core_tags.FilterNode)
def filter(writer, node):
    writer.start_block()
    writer.write("filter ")
    writer.filters(node.filter_expr.filters, True)
    writer.end_block()
    writer.body(node.nodelist)
    writer.tag("endfilter")


@node(core_tags.AutoEscapeControlNode)
def autoescape_control(writer, node):
    original = writer.autoescape
    writer.autoescape = node.setting
    writer.body(node.nodelist)
    writer.autoescape = original


@node(core_tags.SpacelessNode)
def spaceless(writer, node):
    original = writer.spaceless
    writer.spaceless = True
    writer.warn("entering spaceless mode with different semantics", node)
    # do the initial stripping
    nodelist = list(node.nodelist)
    if nodelist:
        if isinstance(nodelist[0], TextNode):
            nodelist[0] = TextNode(nodelist[0].s.lstrip())
        if isinstance(nodelist[-1], TextNode):
            nodelist[-1] = TextNode(nodelist[-1].s.rstrip())
    writer.body(nodelist)
    writer.spaceless = original


@node(core_tags.TemplateTagNode)
def template_tag(writer, node):
    tag = {
        "openblock": writer.block_start_string,
        "closeblock": writer.block_end_string,
        "openvariable": writer.variable_start_string,
        "closevariable": writer.variable_end_string,
        "opencomment": writer.comment_start_string,
        "closecomment": writer.comment_end_string,
        "openbrace": "{",
        "closebrace": "}",
    }.get(node.tagtype)
    if tag:
        writer.start_variable()
        writer.literal(tag)
        writer.end_variable()


@node(core_tags.URLNode)
def url_tag(writer, node):
    writer.warn("url node used.  make sure to provide a proper url() function", node)
    if node.asvar:
        writer.start_block()
        writer.write("set %s = " % node.asvar)
    else:
        writer.start_variable()
    writer.write("url(")
    writer.literal(node.view_name)
    for arg in node.args:
        writer.write(", ")
        writer.node(arg)
    for key, arg in node.kwargs.items():
        writer.write(", %s=" % key)
        writer.node(arg)
    writer.write(")")
    if node.asvar:
        writer.end_block()
    else:
        writer.end_variable()


@node(core_tags.WidthRatioNode)
def width_ratio(writer, node):
    writer.warn(
        "widthratio expanded into formula.  You may want to provide "
        "a helper function for this calculation",
        node,
    )
    writer.start_variable()
    writer.write("(")
    writer.node(node.val_expr)
    writer.write(" / ")
    writer.node(node.max_expr)
    writer.write(" * ")
    writer.write(str(int(node.max_width)))
    writer.write(")|round|int")
    writer.end_variable(always_safe=True)


@node(core_tags.WithNode)
def with_block(writer, node):
    writer.warn(
        "with block expanded into set statement.  This could cause "
        "variables following that block to be overridden.",
        node,
    )
    writer.start_block()
    writer.write("set %s = " % node.name)
    writer.node(node.var)
    writer.end_block()
    writer.body(node.nodelist)


@node(core_tags.RegroupNode)
def regroup(writer, node):
    if node.expression.var.literal:
        writer.warn(
            "literal in groupby filter used.   Behavior in that "
            "situation is undefined and translation is skipped.",
            node,
        )
        return
    elif node.expression.filters:
        writer.warn(
            "filters in groupby filter used.   Behavior in that "
            "situation is undefined which is most likely a bug "
            "in your code.  Filters were ignored.",
            node,
        )
    writer.start_block()
    writer.write("set %s = " % node.var_name)
    writer.node(node.target)
    writer.write("|groupby(")
    writer.literal(node.expression.var.var)
    writer.write(")")
    writer.end_block()


@node(core_tags.LoadNode)
def warn_load(writer, node):
    writer.warn("load statement used which was ignored on conversion", node)


@node(i18n_tags.GetAvailableLanguagesNode)
def get_available_languages(writer, node):
    writer.warn("make sure to provide a get_available_languages function", node)
    writer.tag(
        "set %s = get_available_languages()"
        % writer.translate_variable_name(node.variable)
    )


@node(i18n_tags.GetCurrentLanguageNode)
def get_current_language(writer, node):
    writer.warn("make sure to provide a get_current_language function", node)
    writer.tag(
        "set %s = get_current_language()"
        % writer.translate_variable_name(node.variable)
    )


@node(i18n_tags.GetCurrentLanguageBidiNode)
def get_current_language_bidi(writer, node):
    writer.warn("make sure to provide a get_current_language_bidi function", node)
    writer.tag(
        "set %s = get_current_language_bidi()"
        % writer.translate_variable_name(node.variable)
    )


@node(i18n_tags.TranslateNode)
def simple_gettext(writer, node):
    writer.warn("i18n system used, make sure to install translations", node)
    writer.start_variable()
    writer.write("_(")
    writer.node(node.value)
    writer.write(")")
    writer.end_variable()


@node(i18n_tags.BlockTranslateNode)
def translate_block(writer, node):
    first_var = []
    variables = set()

    def touch_var(name):
        variables.add(name)
        if not first_var:
            first_var.append(name)

    def dump_token_list(tokens):
        for token in tokens:
            if token.token_type == TOKEN_TEXT:
                writer.write(token.contents)
            elif token.token_type == TOKEN_VAR:
                writer.print_expr(token.contents)
                touch_var(token.contents)

    writer.warn("i18n system used, make sure to install translations", node)
    writer.start_block()
    writer.write("trans")
    idx = -1
    for idx, (key, var) in enumerate(node.extra_context.items()):
        if idx:
            writer.write(",")
        writer.write(" %s=" % key)
        touch_var(key)
        writer.node(var.filter_expression)

    if node.plural and node.countervar and node.counter:
        plural_var = node.countervar
        if plural_var not in variables:
            if idx > -1:
                writer.write(",")
            touch_var(plural_var)
            writer.write(" %s=" % plural_var)
            writer.node(node.counter)

    writer.end_block()
    dump_token_list(node.singular)
    if node.plural and node.countervar and node.counter:
        writer.start_block()
        writer.write("pluralize")
        if node.countervar != first_var[0]:
            writer.write(" " + node.countervar)
        writer.end_block()
        dump_token_list(node.plural)
    writer.tag("endtrans")


@node("SimpleNode")
def simple_tag(writer, node):
    """Check if the simple tag exist as a filter in """
    name = node.tag_name
    if (
        writer.env
        and name not in writer.env.filters
        and name not in writer._filters_warned
    ):
        writer._filters_warned.add(name)
        writer.warn("Filter %s probably doesn't exist in Jinja" % name)

    if not node.vars_to_resolve:
        # No argument, pass the request
        writer.start_variable()
        writer.write("request|")
        writer.write(name)
        writer.end_variable()
        return

    first_var = node.vars_to_resolve[0]
    args = node.vars_to_resolve[1:]
    writer.start_variable()

    # Copied from Writer.filters()
    writer.node(first_var)

    writer.write("|")
    writer.write(name)
    if args:
        writer.write("(")
        for idx, var in enumerate(args):
            if idx:
                writer.write(", ")
            if var.var:
                writer.node(var)
            else:
                writer.literal(var.literal)
        writer.write(")")
    writer.end_variable()


# get rid of node now, it shouldn't be used normally
del node