# -*- coding: utf-8 -*-
"""
Django to Jinja
~~~~~~~~~~~~~~~
Helper module that can convert django templates into Jinja2 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(r"(u|user)\.is_authenticated"), r"\1.is_authenticated()", None),
(re.compile(r"\.non_field_errors"), r".non_field_errors()", None),
(re.compile(r"\.label_tag"), r".label_tag()", None),
(re.compile(r"\.as_dl"), r".as_dl()", None),
(re.compile(r"\.as_table"), r".as_table()", None),
(re.compile(r"\.as_widget"), r".as_widget()", None),
(re.compile(r"\.as_hidden"), r".as_hidden()", None),
(re.compile(r"\.get_([0-9_\w]+)_url"), r".get_\1_url()", None),
(re.compile(r"\.url"), r".url()", re.compile(r"(form|calendar).url")),
(re.compile(r"\.get_([0-9_\w]+)_display"), r".get_\1_display()", None),
(re.compile(r"loop\.counter"), r"loop.index", None),
(re.compile(r"loop\.revcounter"), r"loop.revindex", None),
(re.compile(r"request\.GET\.([0-9_\w]+)"), r"request.GET.get('\1', '')", None),
(re.compile(r"request\.get_host"), r"request.get_host()", None),
(re.compile(r"\.all(?!_)"), r".all()", None),
(re.compile(r"\.all\.0"), r".all()[0]", None),
(re.compile(r"\.([0-9])($|\s+)"), r"[\1]\2", None),
(re.compile(r"\.items"), r".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.
"""
import re
import os
import sys
from jinja2.defaults import *
from django.conf import settings
from django.template import defaulttags as core_tags, loader, TextNode, \
FilterExpression, libraries, Variable, loader_tags, TOKEN_TEXT, \
TOKEN_VAR
from django.template.debug import DebugVariableNode as VariableNode
from django.templatetags import i18n as i18n_tags
from StringIO import StringIO
_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)
f = file(target, 'w')
try:
translate(f, source)
finally:
f.close()
class Writer(object):
"""The core writer class."""
def __init__(self, stream=None, error_stream=None,
block_start_string=BLOCK_START_STRING,
block_end_string=BLOCK_END_STRING,
variable_start_string=VARIABLE_START_STRING,
variable_end_string=VARIABLE_END_STRING,
comment_start_string=COMMENT_START_STRING,
comment_end_string=COMMENT_END_STRING,
initial_autoescape=True,
use_jinja_autoescape=False,
custom_node_handlers=None,
var_re=[],
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 = 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 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 >> self.error_stream, message
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.iteritems():
_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.iteritems():
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 comment_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()
autoescape = writer.autoescape
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 overriden.', 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)
have_plural = False
plural_var = None
if node.plural and node.countervar and node.counter:
have_plural = True
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