"""
import re
from itertools import imap
+import six
+from six.moves import map
+from six.moves import zip
__all__ = ['Markup', 'soft_unicode', 'escape', 'escape_silent']
def __add__(self, other):
if hasattr(other, '__html__') or isinstance(other, basestring):
- return self.__class__(unicode(self) + unicode(escape(other)))
+ return self.__class__(six.text_type(self) + six.text_type(escape(other)))
return NotImplemented
def __radd__(self, other):
if hasattr(other, '__html__') or isinstance(other, basestring):
- return self.__class__(unicode(escape(other)) + unicode(self))
+ return self.__class__(six.text_type(escape(other)) + six.text_type(self))
return NotImplemented
def __mul__(self, num):
except ValueError:
pass
return u''
- return _entity_re.sub(handle_match, unicode(self))
+ return _entity_re.sub(handle_match, six.text_type(self))
def striptags(self):
r"""Unescape markup into an unicode string and strip all tags. This
orig = getattr(unicode, name)
def func(self, *args, **kwargs):
args = _escape_argspec(list(args), enumerate(args))
- _escape_argspec(kwargs, kwargs.iteritems())
+ _escape_argspec(kwargs, six.iteritems(kwargs))
return self.__class__(orig(self, *args, **kwargs))
func.__name__ = orig.__name__
func.__doc__ = orig.__doc__
__getitem__ = lambda s, x: _MarkupEscapeHelper(s.obj[x])
__str__ = lambda s: str(escape(s.obj))
- __unicode__ = lambda s: unicode(escape(s.obj))
+ __unicode__ = lambda s: six.text_type(escape(s.obj))
__repr__ = lambda s: str(escape(repr(s.obj)))
__int__ = lambda s: int(s.obj)
__float__ = lambda s: float(s.obj)
:copyright: Copyright 2010 by the Jinja team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
+from __future__ import print_function
import sys
import os
import re
def main():
if len(sys.argv) != 2:
- print 'error: only argument is path to markupsafe'
+ print('error: only argument is path to markupsafe')
sys.exit(1)
basedir = os.path.dirname(__file__)
markupdir = sys.argv[1]
:license: BSD, see LICENSE for more details.
"""
from jinja2._markupsafe import Markup
+import six
def escape(s):
"""
if hasattr(s, '__html__'):
return s.__html__()
- return Markup(unicode(s)
+ return Markup(six.text_type(s)
.replace('&', '&')
.replace('>', '>')
.replace('<', '<')
string is not converted back to unicode.
"""
if not isinstance(s, unicode):
- s = unicode(s)
+ s = six.text_type(s)
return s
import gc
import unittest
from jinja2._markupsafe import Markup, escape, escape_silent
+import six
class MarkupTestCase(unittest.TestCase):
# adding two strings should escape the unsafe one
unsafe = '<script type="application/x-some-script">alert("foo");</script>'
safe = Markup('<em>username</em>')
- assert unsafe + safe == unicode(escape(unsafe)) + unicode(safe)
+ assert unsafe + safe == six.text_type(escape(unsafe)) + six.text_type(safe)
# string interpolations are safe to use too
assert Markup('<em>%s</em>') % '<bad user>' == \
def test_markup_leaks(self):
counts = set()
- for count in xrange(20):
- for item in xrange(1000):
+ for count in range(20):
+ for item in range(1000):
escape("foo")
escape("<foo>")
escape(u"foo")
from jinja2.visitor import NodeVisitor
from jinja2.exceptions import TemplateAssertionError
from jinja2.utils import Markup, concat, escape, is_python_keyword, next
+import six
+from six.moves import map
+from six.moves import zip
operators = {
}
try:
- exec '(0 if 0 else 0)'
+ exec('(0 if 0 else 0)')
except SyntaxError:
have_condexpr = False
else:
def f():
if 0: dummy(x)
return f
-unoptimize_before_dead_code = bool(unoptimize_before_dead_code().func_closure)
+unoptimize_before_dead_code = bool(unoptimize_before_dead_code().__closure__)
def generate(node, environment, name, filename, stream=None,
return False
return True
elif isinstance(value, dict):
- for key, value in value.iteritems():
+ for key, value in six.iteritems(value):
if not has_safe_repr(key):
return False
if not has_safe_repr(value):
self.write(', ')
self.visit(kwarg, frame)
if extra_kwargs is not None:
- for key, value in extra_kwargs.iteritems():
+ for key, value in six.iteritems(extra_kwargs):
self.write(', %s=%s' % (key, value))
if node.dyn_args:
self.write(', *')
self.visit(kwarg.value, frame)
self.write(', ')
if extra_kwargs is not None:
- for key, value in extra_kwargs.iteritems():
+ for key, value in six.iteritems(extra_kwargs):
self.write('%r: %s, ' % (key, value))
if node.dyn_kwargs is not None:
self.write('}, **')
def pop_scope(self, aliases, frame):
"""Restore all aliases and delete unused variables."""
- for name, alias in aliases.iteritems():
+ for name, alias in six.iteritems(aliases):
self.writeline('l_%s = %s' % (name, alias))
to_delete = set()
for name in frame.identifiers.declared_locally:
self.outdent(2 + (not self.has_known_extends))
# at this point we now have the blocks collected and can visit them too.
- for name, block in self.blocks.iteritems():
+ for name, block in six.iteritems(self.blocks):
block_frame = Frame(eval_ctx)
block_frame.inspect(block.body)
block_frame.block = name
return
if self.environment.finalize:
- finalize = lambda x: unicode(self.environment.finalize(x))
+ finalize = lambda x: six.text_type(self.environment.finalize(x))
else:
finalize = unicode
from types import TracebackType
from jinja2.utils import CodeType, missing, internal_code
from jinja2.exceptions import TemplateSyntaxError
+import six
# on pypy we can take advantage of transparent proxies
try:
# how does the raise helper look like?
try:
- exec "raise TypeError, 'foo'"
+ exec("raise TypeError, 'foo'")
except SyntaxError:
raise_helper = 'raise __jinja_exception__[1]'
except TypeError:
frames = []
# skip some internal frames if wanted
- for x in xrange(initial_skip):
+ for x in range(initial_skip):
if tb is not None:
tb = tb.tb_next
initial_tb = tb
locals = ctx.get_all()
else:
locals = {}
- for name, value in real_locals.iteritems():
+ for name, value in six.iteritems(real_locals):
if name.startswith('l_') and value is not missing:
locals[name[2:]] = value
# execute the code and catch the new traceback
try:
- exec code in globals, locals
+ exec(code, globals, locals)
except:
exc_info = sys.exc_info()
new_tb = exc_info[2].tb_next
TemplatesNotFound
from jinja2.utils import import_string, LRUCache, Markup, missing, \
concat, consume, internalcode, _encode_filename
+import six
+from functools import reduce
+from six.moves import filter
+from six.moves import map
+from six.moves import zip
# for direct template usage we have up to ten living environments
yet. This is used by :ref:`extensions <writing-extensions>` to register
callbacks and configuration values without breaking inheritance.
"""
- for key, value in attributes.iteritems():
+ for key, value in six.iteritems(attributes):
if not hasattr(self, key):
setattr(self, key, value)
rv.overlayed = True
rv.linked_to = self
- for key, value in args.iteritems():
+ for key, value in six.iteritems(args):
if value is not missing:
setattr(rv, key, value)
rv.cache = copy_cache(self.cache)
rv.extensions = {}
- for key, value in self.extensions.iteritems():
+ for key, value in six.iteritems(self.extensions):
rv.extensions[key] = value.bind(rv)
if extensions is not missing:
rv.extensions.update(load_extensions(rv, extensions))
of the extensions to be applied you have to filter source through
the :meth:`preprocess` method.
"""
- source = unicode(source)
+ source = six.text_type(source)
try:
return self.lexer.tokeniter(source, name, filename)
except TemplateSyntaxError:
because there you usually only want the actual source tokenized.
"""
return reduce(lambda s, e: e.preprocess(s, name, filename),
- self.iter_extensions(), unicode(source))
+ self.iter_extensions(), six.text_type(source))
def _tokenize(self, source, name, filename=None, state=None):
"""Called by the parser to do the preprocessing and filtering
def write_file(filename, data, mode):
if zip:
info = ZipInfo(filename)
- info.external_attr = 0755 << 16L
+ info.external_attr = 0o755 << 16
zip_file.writestr(info, data)
else:
f = open(os.path.join(target, filename), mode)
source, filename, _ = self.loader.get_source(self, name)
try:
code = self.compile(source, name, filename, True, True)
- except TemplateSyntaxError, e:
+ except TemplateSyntaxError as e:
if not ignore_errors:
raise
log_function('Could not compile "%s": %s' % (name, e))
'environment': environment,
'__file__': code.co_filename
}
- exec code in namespace
+ exec(code, namespace)
rv = cls._from_namespace(environment, namespace, globals)
rv._uptodate = uptodate
return rv
return Markup(concat(self._body_stream))
def __str__(self):
- return unicode(self).encode('utf-8')
+ return six.text_type(self).encode('utf-8')
# unicode goes after __str__ because we configured 2to3 to rename
# __unicode__ to __str__. because the 2to3 tree is not designed to
:copyright: (c) 2010 by the Jinja Team.
:license: BSD, see LICENSE for more details.
"""
+import six
+from six.moves import map
+from six.moves import zip
class TemplateError(Exception):
def __init__(self, message=None):
if message is not None:
- message = unicode(message).encode('utf-8')
+ message = six.text_type(message).encode('utf-8')
Exception.__init__(self, message)
@property
self.translated = False
def __str__(self):
- return unicode(self).encode('utf-8')
+ return six.text_type(self).encode('utf-8')
# unicode goes after __str__ because we configured 2to3 to rename
# __unicode__ to __str__. because the 2to3 tree is not designed to
from jinja2.runtime import Undefined, concat
from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
from jinja2.utils import contextfunction, import_string, Markup, next
+import six
# the only real useful gettext functions for a Jinja template. Note
# enough to handle the variable expansion and autoescape
# handling itself
if self.environment.newstyle_gettext:
- for key, value in variables.iteritems():
+ for key, value in six.iteritems(variables):
# the function adds that later anyways in case num was
# called num, so just skip it.
if num_called_num and key == 'num':
try:
node = environment.parse(source)
tokens = list(environment.lex(environment.preprocess(source)))
- except TemplateSyntaxError, e:
+ except TemplateSyntaxError as e:
if not silent:
raise
# skip templates with syntax errors
unicode_urlencode
from jinja2.runtime import Undefined
from jinja2.exceptions import FilterArgumentError
+import six
+from six.moves import map
+from six.moves import zip
_word_re = re.compile(r'\w+(?u)')
"""Enforce HTML escaping. This will probably double escape variables."""
if hasattr(value, '__html__'):
value = value.__html__()
- return escape(unicode(value))
+ return escape(six.text_type(value))
def do_urlencode(value):
"""
itemiter = None
if isinstance(value, dict):
- itemiter = value.iteritems()
+ itemiter = six.iteritems(value)
elif not isinstance(value, basestring):
try:
itemiter = iter(value)
if count is None:
count = -1
if not eval_ctx.autoescape:
- return unicode(s).replace(unicode(old), unicode(new), count)
+ return six.text_type(s).replace(six.text_type(old), six.text_type(new), count)
if hasattr(old, '__html__') or hasattr(new, '__html__') and \
not hasattr(s, '__html__'):
s = escape(s)
"""
rv = u' '.join(
u'%s="%s"' % (escape(key), escape(value))
- for key, value in d.iteritems()
+ for key, value in six.iteritems(d)
if value is not None and not isinstance(value, Undefined)
)
if autospace and rv:
# no automatic escaping? joining is a lot eaiser then
if not eval_ctx.autoescape:
- return unicode(d).join(imap(unicode, value))
+ return six.text_type(d).join(imap(unicode, value))
# if the delimiter doesn't have an html representation we check
# if any of the items has. If yes we do a coercion to Markup
if hasattr(item, '__html__'):
do_escape = True
else:
- value[idx] = unicode(item)
+ value[idx] = six.text_type(item)
if do_escape:
d = escape(d)
else:
- d = unicode(d)
+ d = six.text_type(d)
return d.join(value)
# no html involved, to normal joining
def do_center(value, width=80):
"""Centers the value in a field of a given width."""
- return unicode(value).center(width)
+ return six.text_type(value).center(width)
@environmentfilter
def do_first(environment, seq):
"""Return the first item of a sequence."""
try:
- return iter(seq).next()
+ return six.advance_iterator(iter(seq))
except StopIteration:
return environment.undefined('No first item, sequence was empty.')
def do_last(environment, seq):
"""Return the last item of a sequence."""
try:
- return iter(reversed(seq)).next()
+ return six.advance_iterator(iter(reversed(seq)))
except StopIteration:
return environment.undefined('No last item, sequence was empty.')
"""
if hasattr(value, '__html__'):
value = value.__html__()
- return Markup(unicode(value)).striptags()
+ return Markup(six.text_type(value)).striptags()
def do_slice(value, slices, fill_with=None):
items_per_slice = length // slices
slices_with_extra = length % slices
offset = 0
- for slice_number in xrange(slices):
+ for slice_number in range(slices):
start = offset + slice_number * items_per_slice
if slice_number < slices_with_extra:
offset += 1
grouper = property(itemgetter(0))
list = property(itemgetter(1))
- def __new__(cls, (key, value)):
+ def __new__(cls, xxx_todo_changeme):
+ (key, value) = xxx_todo_changeme
return tuple.__new__(cls, (key, list(value)))
def do_mark_unsafe(value):
"""Mark a value as unsafe. This is the reverse operation for :func:`safe`."""
- return unicode(value)
+ return six.text_type(value)
def do_reverse(value):
from collections import deque
from jinja2.exceptions import TemplateSyntaxError
from jinja2.utils import LRUCache, next
+import six
# cache for the lexers. Exists in order to be able to have multiple
';': TOKEN_SEMICOLON
}
-reverse_operators = dict([(v, k) for k, v in operators.iteritems()])
+reverse_operators = dict([(v, k) for k, v in six.iteritems(operators)])
assert len(operators) == len(reverse_operators), 'operators dropped'
operator_re = re.compile('(%s)' % '|'.join(re.escape(x) for x in
sorted(operators, key=lambda x: -len(x))))
def skip(self, n=1):
"""Got n tokens ahead."""
- for x in xrange(n):
+ for x in range(n):
next(self)
def next_if(self, expr):
value = self._normalize_newlines(value[1:-1]) \
.encode('ascii', 'backslashreplace') \
.decode('unicode-escape')
- except Exception, e:
+ except Exception as e:
msg = str(e).split(':')[-1].strip()
raise TemplateSyntaxError(msg, lineno, name, filename)
# if we can express it as bytestring (ascii only)
"""This method tokenizes the text and returns the tokens in a
generator. Use this method if you just want to tokenize a template.
"""
- source = '\n'.join(unicode(source).splitlines())
+ source = '\n'.join(six.text_type(source).splitlines())
pos = 0
lineno = 1
stack = ['root']
# yield for the current token the first named
# group that matched
elif token == '#bygroup':
- for key, value in m.groupdict().iteritems():
+ for key, value in six.iteritems(m.groupdict()):
if value is not None:
yield lineno, key, value
lineno += value.count('\n')
stack.pop()
# resolve the new state by group checking
elif new_state == '#bygroup':
- for key, value in m.groupdict().iteritems():
+ for key, value in six.iteritems(m.groupdict()):
if value is not None:
stack.append(key)
break
import weakref
from types import ModuleType
from os import path
+import six
try:
from hashlib import sha1
except ImportError:
def list_templates(self):
result = []
- for prefix, loader in self.mapping.iteritems():
+ for prefix, loader in six.iteritems(self.mapping):
for template in loader.list_templates():
result.append(prefix + self.delimiter + template)
return result
from itertools import chain, izip
from collections import deque
from jinja2.utils import Markup, MethodType, FunctionType
+import six
#: the types we support for context functions
setattr(self, attr, attributes.pop(attr, None))
if attributes:
raise TypeError('unknown attribute %r' %
- iter(attributes).next())
+ six.advance_iterator(iter(attributes)))
def iter_fields(self, exclude=None, only=None):
"""This method iterates over all fields that are defined and yields
constant value in the generated code, otherwise it will raise
an `Impossible` exception.
"""
- from compiler import has_safe_repr
+ from .compiler import has_safe_repr
if not has_safe_repr(value):
raise Impossible()
return cls(value, lineno=lineno, environment=environment)
def as_const(self, eval_ctx=None):
eval_ctx = get_eval_context(self, eval_ctx)
- return ''.join(unicode(x.as_const(eval_ctx)) for x in self.nodes)
+ return ''.join(six.text_type(x.as_const(eval_ctx)) for x in self.nodes)
class Compare(Expr):
from jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError
from jinja2.utils import next
from jinja2.lexer import describe_token, describe_token_expr
+from six.moves import map
+from six.moves import zip
#: statements that callinto
concat, internalcode, next, object_type_repr
from jinja2.exceptions import UndefinedError, TemplateRuntimeError, \
TemplateNotFound
+import six
# these variables are exported to the template runtime
# we don't want to modify the dict passed
if shared:
parent = dict(parent)
- for key, value in locals.iteritems():
+ for key, value in six.iteritems(locals):
if key[:2] == 'l_' and value is not missing:
parent[key[2:]] = value
return Context(environment, parent, template_name, blocks)
# create the initial mapping of blocks. Whenever template inheritance
# takes place the runtime will update this mapping with the new blocks
# from the template.
- self.blocks = dict((k, [v]) for k, v in blocks.iteritems())
+ self.blocks = dict((k, [v]) for k, v in six.iteritems(blocks))
def super(self, name, current):
"""Render a parent block."""
self.parent, True, None, locals)
context.vars.update(self.vars)
context.eval_ctx = self.eval_ctx
- context.blocks.update((k, list(v)) for k, v in self.blocks.iteritems())
+ context.blocks.update((k, list(v)) for k, v in six.iteritems(self.blocks))
return context
def _all(meth):
_fail_with_undefined_error
def __str__(self):
- return unicode(self).encode('utf-8')
+ return six.text_type(self).encode('utf-8')
# unicode goes after __str__ because we configured 2to3 to rename
# __unicode__ to __str__. because the 2to3 tree is not designed to
"""A range that can't generate ranges with a length of more than
MAX_RANGE items.
"""
- rng = xrange(*args)
+ rng = range(*args)
if len(rng) > MAX_RANGE:
raise OverflowError('range too big, maximum size for range is %d' %
MAX_RANGE)
"""
import re
from jinja2.runtime import Undefined
+import six
try:
from collections import Mapping as MappingType
def test_lower(value):
"""Return true if the variable is lowercased."""
- return unicode(value).islower()
+ return six.text_type(value).islower()
def test_upper(value):
"""Return true if the variable is uppercased."""
- return unicode(value).isupper()
+ return six.text_type(value).isupper()
def test_string(value):
def assert_traceback_matches(self, callback, expected_tb):
try:
callback()
- except Exception, e:
+ except Exception as e:
tb = format_exception(*sys.exc_info())
if re.search(expected_tb.strip(), ''.join(tb)) is None:
raise self.fail('Traceback did not match:\n\n%s\nexpected:\n%s'
StrictUndefined, UndefinedError, meta, \
is_undefined, Template, DictLoader
from jinja2.utils import Cycler
+import six
env = Environment()
c = Cycler(*items)
for item in items + items:
assert c.current == item
- assert c.next() == item
- c.next()
+ assert six.advance_iterator(c) == item
+ six.advance_iterator(c)
assert c.current == 2
c.reset()
assert c.current == 1
def test_find_refererenced_templates(self):
ast = env.parse('{% extends "layout.html" %}{% include helper %}')
i = meta.find_referenced_templates(ast)
- assert i.next() == 'layout.html'
- assert i.next() is None
+ assert six.advance_iterator(i) == 'layout.html'
+ assert six.advance_iterator(i) is None
assert list(i) == []
ast = env.parse('{% extends "layout.html" %}'
def test_basic_streaming(self):
tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index "
"}} - {{ item }}</li>{%- endfor %}</ul>")
- stream = tmpl.stream(seq=range(4))
- self.assert_equal(s
tream.next(), '<ul>')
- self.assert_equal(stream.next(), '<li>1 - 0</li>')
- self.assert_equal(stream.next(), '<li>2 - 1</li>')
- self.assert_equal(stream.next(), '<li>3 - 2</li>')
- self.assert_equal(stream.next(), '<li>4 - 3</li>')
- self.assert_equal(stream.next(), '</ul>')
+ stream = tmpl.stream(seq=list(range(4)))
+ self.assert_equal(s
ix.advance_iterator(stream), '<ul>')
+ self.assert_equal(six.advance_iterator(stream), '<li>1 - 0</li>')
+ self.assert_equal(six.advance_iterator(stream), '<li>2 - 1</li>')
+ self.assert_equal(six.advance_iterator(stream), '<li>3 - 2</li>')
+ self.assert_equal(six.advance_iterator(stream), '<li>4 - 3</li>')
+ self.assert_equal(six.advance_iterator(stream), '</ul>')
def test_buffered_streaming(self):
tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index "
"}} - {{ item }}</li>{%- endfor %}</ul>")
- stream = tmpl.stream(seq=range(4))
+ stream = tmpl.stream(seq=list(range(4)))
stream.enable_buffering(size=3)
- self.assert_equal(s
tream.next(), u'<ul><li>1 - 0</li><li>2 - 1</li>')
- self.assert_equal(stream.next(), u'<li>3 - 2</li><li>4 - 3</li></ul>')
+ self.assert_equal(s
ix.advance_iterator(stream), u'<ul><li>1 - 0</li><li>2 - 1</li>')
+ self.assert_equal(six.advance_iterator(stream), u'<li>3 - 2</li><li>4 - 3</li></ul>')
def test_streaming_behavior(self):
tmpl = env.from_string("")
def test_none_gives_proper_error(self):
try:
Environment().getattr(None, 'split')()
- except UndefinedError, e:
+ except UndefinedError as e:
assert e.message == "'None' has no attribute 'split'"
else:
assert False, 'expected exception'
def test_object_repr(self):
try:
Undefined(obj=42, name='upper')()
- except UndefinedError, e:
+ except UndefinedError as e:
assert e.message == "'int object' has no attribute 'upper'"
else:
assert False, 'expected exception'
def test_simple(self):
tmpl = env.from_string('{% for item in seq %}{{ item }}{% endfor %}')
- assert tmpl.render(seq=range(10)) == '0123456789'
+ assert tmpl.render(seq=list(range(10))) == '0123456789'
def test_else(self):
tmpl = env.from_string('{% for item in seq %}XXX{% else %}...{% endfor %}')
tmpl = env.from_string('''{% for item in seq %}{{
loop.cycle('<1>', '<2>') }}{% endfor %}{%
for item in seq %}{{ loop.cycle(*through) }}{% endfor %}''')
- output = tmpl.render(seq=range(4), through=('<1>', '<2>'))
+ output = tmpl.render(seq=list(range(4)), through=('<1>', '<2>'))
assert output == '<1><2>' * 4
def test_scope(self):
tmpl = env.from_string('{% for item in seq %}{% endfor %}{{ item }}')
- output = tmpl.render(seq=range(10))
+ output = tmpl.render(seq=list(range(10)))
assert not output
def test_varlen(self):
from jinja2.ext import Extension
from jinja2.lexer import Token, count_newlines
from jinja2.utils import next
+import six
# 2.x / 3.x
try:
original = Environment(extensions=[TestExtension])
overlay = original.overlay()
for env in original, overlay:
- for ext in env.extensions.itervalues():
+ for ext in six.itervalues(env.extensions):
assert ext.environment is env
def test_preprocessor_extension(self):
from jinja2.testsuite import JinjaTestCase
from jinja2 import Markup, Environment
+import six
+from six.moves import map
+from six.moves import zip
env = Environment()
def test_batch(self):
tmpl = env.from_string("{{ foo|batch(3)|list }}|"
"{{ foo|batch(3, 'X')|list }}")
- out = tmpl.render(foo=range(10))
+ out = tmpl.render(foo=list(range(10)))
assert out == ("[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]|"
"[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 'X', 'X']]")
def test_slice(self):
tmpl = env.from_string('{{ foo|slice(3)|list }}|'
'{{ foo|slice(3, "X")|list }}')
- out = tmpl.render(foo=range(10))
+ out = tmpl.render(foo=list(range(10)))
assert out == ("[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|"
"[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]")
def test_first(self):
tmpl = env.from_string('{{ foo|first }}')
- out = tmpl.render(foo=range(10))
+ out = tmpl.render(foo=list(range(10)))
assert out == '0'
def test_float(self):
def test_last(self):
tmpl = env.from_string('''{{ foo|last }}''')
- out = tmpl.render(foo=range(10))
+ out = tmpl.render(foo=list(range(10)))
assert out == '9'
def test_length(self):
def test_pprint(self):
from pprint import pformat
tmpl = env.from_string('''{{ data|pprint }}''')
- data = range(1000)
+ data = list(range(1000))
assert tmpl.render(data=data) == pformat(data)
def test_random(self):
tmpl = env.from_string('''{{ seq|random }}''')
- seq = range(100)
+ seq = list(range(100))
for _ in range(10):
assert int(tmpl.render(seq=seq)) in seq
def test_string(self):
x = [1, 2, 3, 4, 5]
tmpl = env.from_string('''{{ obj|string }}''')
- assert tmpl.render(obj=x) == unicode(x)
+ assert tmpl.render(obj=x) == six.text_type(x)
def test_title(self):
tmpl = env.from_string('''{{ "foo bar"|title }}''')
def __init__(self, value):
self.value = value
def __unicode__(self):
- return unicode(self.value)
+ return six.text_type(self.value)
tmpl = env.from_string('''{{ items|sort(attribute='value')|join }}''')
assert tmpl.render(items=map(Magic, [3, 2, 4, 1])) == '1234'
self.assert_raises(TemplateNotFound, t.render)
try:
t.render()
- except TemplatesNotFound, e:
+ except TemplatesNotFound as e:
assert e.templates == ['missing', 'missing2']
assert e.name == 'missing2'
else:
}))
t = env.from_string('{% extends "master.html" %}{% block item %}'
'{{ item }}{% endblock %}')
- assert t.render(seq=range(5)) == '[0][1][2][3][4]'
+ assert t.render(seq=list(range(5))) == '[0][1][2][3][4]'
def test_super_in_scoped_block(self):
env = Environment(loader=DictLoader({
}))
t = env.from_string('{% extends "master.html" %}{% block item %}'
'{{ super() }}|{{ item * 2 }}{% endblock %}')
- assert t.render(seq=range(5)) == '[0|0][1|2][2|4][3|6][4|8]'
+ assert t.render(seq=list(range(5))) == '[0|0][1|2][2|4][3|6][4|8]'
def test_scoped_block_after_inheritance(self):
env = Environment(loader=DictLoader({
from jinja2 import Environment, Template, TemplateSyntaxError, \
UndefinedError, nodes
+import six
env = Environment()
env = Environment('{%', '%}', '${', '}')
tmpl = env.from_string('''{% for item in seq
%}${{'foo': item}|upper}{% endfor %}''')
- assert tmpl.render(seq=range(3)) == "{'FOO': 0}{'FOO': 1}{'FOO': 2}"
+ assert tmpl.render(seq=list(range(3))) == "{'FOO': 0}{'FOO': 1}{'FOO': 2}"
def test_comments(self):
env = Environment('<!--', '-->', '{', '}')
<li>{item}</li>
<!--- endfor -->
</ul>''')
- assert tmpl.render(seq=
range(3)) == ("<ul>\n <li>0</li>\n "
+ assert tmpl.render(seq=
list(range(3))) == ("<ul>\n <li>0</li>\n "
"<li>1</li>\n <li>2</li>\n</ul>")
def test_string_escapes(self):
def test_operators(self):
from jinja2.lexer import operators
- for test, expect in operators.iteritems():
+ for test, expect in six.iteritems(operators):
if test in '([{}])':
continue
stream = env.lexer.tokenize('{{ %s }}' % test)
- stream.next()
+ six.advance_iterator(stream)
assert stream.current.type == expect
def test_normalizing(self):
<? for item in seq -?>
<?= item ?>
<?- endfor ?>''')
- assert tmpl.render(seq=range(5)) == '01234'
+ assert tmpl.render(seq=list(range(5))) == '01234'
def test_erb_syntax(self):
env = Environment('<%', '%>', '<%=', '%>', '<%#', '%>')
<% for item in seq -%>
<%= item %>
<%- endfor %>''')
- assert tmpl.render(seq=range(5)) == '01234'
+ assert tmpl.render(seq=list(range(5))) == '01234'
def test_comment_syntax(self):
env = Environment('<!--', '-->', '${', '}', '<!--#', '-->')
<!-- for item in seq --->
${item}
<!--- endfor -->''')
- assert tmpl.render(seq=range(5)) == '01234'
+ assert tmpl.render(seq=list(range(5))) == '01234'
def test_balancing(self):
tmpl = env.from_string('''{{{'foo':'bar'}.foo}}''')
% for item in seq:
${item}
% endfor''')
- assert [int(x.strip()) for x in tmpl.render(seq=range(5)).split()] == \
- range(5)
+ assert [int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()] == \
+ list(range(5))
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##')
tmpl = env.from_string('''\
% for item in seq:
${item} ## the rest of the stuff
% endfor''')
- assert [int(x.strip()) for x in tmpl.render(seq=range(5)).split()] == \
- range(5)
+ assert [int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()] == \
+ list(range(5))
def test_line_syntax_priority(self):
# XXX: why is the whitespace there in front of the newline?
def assert_error(code, expected):
try:
Template(code)
- except TemplateSyntaxError, e:
+ except TemplateSyntaxError as e:
assert str(e) == expected, 'unexpected error message'
else:
assert False, 'that was supposed to be an error'
assert tmpl.render() == 'foobarbaz'
def test_notin(self):
- bar = xrange(100)
+ bar = range(100)
tmpl = env.from_string('''{{ not 42 in bar }}''')
- assert tmpl.render(bar=bar) == unicode(not 42 in bar)
+ assert tmpl.render(bar=bar) == six.text_type(not 42 in bar)
def test_implicit_subscribed_tuple(self):
class Foo(object):
from jinja2 import Template, Environment, DictLoader, TemplateSyntaxError, \
TemplateNotFound, PrefixLoader
+from six.moves import map
+from six.moves import zip
env = Environment()
''')
- assert tmpl.render().split() == map(unicode, range(1, 11)) * 5
+ assert tmpl.render().split() == map(unicode, list(range(1, 11))) * 5
def test_weird_inline_comment(self):
env = Environment(line_statement_prefix='%')
}))
try:
env.get_template('foo/bar.html')
- except TemplateNotFound, e:
+ except TemplateNotFound as e:
assert e.name == 'foo/bar.html'
else:
assert False, 'expected error here'
from jinja2 import Markup, escape
from jinja2.exceptions import SecurityError, TemplateSyntaxError, \
TemplateRuntimeError
+import six
class PrivateStuff(object):
# adding two strings should escape the unsafe one
unsafe = '<script type="application/x-some-script">alert("foo");</script>'
safe = Markup('<em>username</em>')
- assert unsafe + safe == unicode(escape(unsafe)) + unicode(safe)
+ assert unsafe + safe == six.text_type(escape(unsafe)) + six.text_type(safe)
# string interpolations are safe to use too
assert Markup('<em>%s</em>') % '<bad user>' == \
'{{ say_hello("<blink>foo</blink>") }}')
escaped_out = '<p>Hello <blink>foo</blink>!</p>'
assert t.render() == escaped_out
- assert unicode(t.module) == escaped_out
+ assert six.text_type(t.module) == escaped_out
assert escape(t.module) == escaped_out
assert t.module.say_hello('<blink>foo</blink>') == escaped_out
assert escape(t.module.say_hello('<blink>foo</blink>')) == escaped_out
t = env.from_string('{{ %s }}' % expr)
try:
t.render(ctx)
- except TemplateRuntimeError, e:
+ except TemplateRuntimeError as e:
pass
else:
self.fail('expected runtime error')
t = env.from_string('{{ %s }}' % expr)
try:
t.render(ctx)
- except TemplateRuntimeError, e:
+ except TemplateRuntimeError as e:
pass
else:
self.fail('expected runtime error')
def test_markup_leaks(self):
counts = set()
- for count in xrange(20):
- for item in xrange(1000):
+ for count in range(20):
+ for item in range(1000):
escape("foo")
escape("<foo>")
escape(u"foo")
import re
import sys
import errno
+import six
try:
from urllib.parse import quote_from_bytes as url_quote
except ImportError:
raise TypeError(_test_gen_bug)
yield None
_concat(_test_gen_bug())
-except TypeError, _error:
+except TypeError as _error:
if not _error.args or _error.args[0] is not _test_gen_bug:
def concat(gen):
try:
next = next
except NameError:
def next(x):
- return x.next()
+ return six.advance_iterator(x)
# if this python version is unable to deal with unicode filenames
FunctionType = type(_func)
GeneratorType = type(_func())
MethodType = type(_C.method)
-CodeType = type(_C.method.func_code)
+CodeType = type(_C.method.__code__)
try:
raise TypeError()
except TypeError:
def internalcode(f):
"""Marks the function as internally used"""
- internal_code.add(f.func_code)
+ internal_code.add(f.__code__)
return f
"""
try:
return open(filename, mode)
- except IOError, e:
+ except IOError as e:
if e.errno not in (errno.ENOENT, errno.EISDIR):
raise
trim_url = lambda x, limit=trim_url_limit: limit is not None \
and (x[:limit] + (len(x) >=limit and '...'
or '')) or x
- words = _word_split_re.split(unicode(escape(text)))
+ words = _word_split_re.split(six.text_type(escape(text)))
nofollow_attr = nofollow and ' rel="nofollow"' or ''
for i, word in enumerate(words):
match = _punctuation_re.match(word)
words = LOREM_IPSUM_WORDS.split()
result = []
- for _ in xrange(n):
+ for _ in range(n):
next_capitalized = True
last_comma = last_fullstop = 0
word = None
p = []
# each paragraph contains out of 20 to 100 words.
- for idx, _ in enumerate(xrange(randrange(min, max))):
+ for idx, _ in enumerate(range(randrange(min, max))):
while True:
word = choice(words)
if word != last:
representation first.
"""
if not isinstance(obj, basestring):
- obj = unicode(obj)
+ obj = six.text_type(obj)
if isinstance(obj, unicode):
obj = obj.encode(charset)
- return unicode(url_quote(obj))
+ return six.text_type(url_quote(obj))
class LRUCache(object):
projects / thirdparty / jinja.git / commitdiff
