Jinja Changelog — Jinja Documentation

# Jinja

## Jinja Changelog

## Version 1.2

(codename to be hatsuyuki, released Nov 17th 2007)

Backwards Incompatible Changes

- call is a keyword now
- the internal parser AST changed
- extends must be the first tag in a template
- the tuple literal yields tuples now, instead of lists.

- environments now have a translator_factory parameter that allows to change the translator without subclassing the environment.
- fixed bug in buffet plugin regarding the package loader
- once again improved debugger.
- added groupby filter.
- added sameas test function.
- standalone parser. Jinja does not use the python parser any more and will continue having the same semantics in any future python versions. This was done in order to simplify updating Jinja to 2.6 and 3.0 and to support non python syntax.
- added support for `expr1 if test else expr2` (conditional expressions)
- `foo.0` as alias for `foo[0]` is possible now. This is mainly for django compatibility.
- the filter operators has a much higher priority now which makes it possible to do `foo|filter + bar|filter`.
- new AST. the return value of Environment.parse is now a Jinja AST and not a Jinja-Python AST. This is also the only backwards incompatible change but should not affect many users because this feature is more or less undocumented and has few use cases.
- tuple syntax returns tuples now and not lists any more.
- the print directive and `{{ variable }}` syntax now accepts and implicit tuple like the for and cycle tags. (`{{ 1, 2 }}` is an implicit alias for `{{ (1, 2) }}` like ``{% for a, b in seq %}` is for `{% for (a, b) in seq %}`.
- tests called with one parameter don't need parentheses. This gives a more natural syntax for the sameas test and some others: `{{ foo is sameas bar }}` instead of `{{ foo is sameas(bar) }}`. If you however want to pass more than one argument you have to use parentheses because `{{ foo is sometest bar, baz }}` is handled as `{{ (foo is sometest(bar), baz) }}`, so as tuple expression.
- removed support for octal character definitions in strings such as `'\14'`, use `'\x0c'` now.
- added regular expression literal. `@/expr/flags` equals `re.compile(r'(?flags)expr')`. This is useful for the matching test and probably some others.
- added set literal. We do not use python3's {1, 2} syntax because this conflicts with the dict literal. To be compatible with the regex literal we use `@(1, 2)` instead.
- fixed bug in get_attribute that disallowed retreiving attributes of objects without a __class__ such as _sre.SRE_Pattern.
- addded django.contrib.jinja which provides advanced support for django. (thanks Bryan McLemore)
- debugger is now able to rewrite the whole traceback, not only the first frame. (requires the optional debugger c module which is compiled automatically on installation if possible)
- if the set that is postfixed with a bang (!) it acts like the python 3 "nonlocal" keyword. This means that you can now override variables defined in the outer scope from within a loop.
- `foo ~ bar` is now a simpler alternative to `foo|string + bar|string`
- PackageLoader can now work without pkg_resources too
- added getattribute and getitem filter.
- added support for the pretty library.
- changed the way the MemcachedLoaderMixin creates the class so that it's possible to hook your own client in.

## Version 1.1

(codename: sinka, released Jun 1, 2007)

- blocks now support `{{ super() }}` to render the parent output.
- debugging system improved, smaller filesize for the cached files. Debugging works now well for any module using linecache.
- `{{ debug() }}` can now be used to get a list of filters and tags.
- the template lexer keeps not track of brace, parenthesis and bracket balance in order to not break variable tags apart if they are configured to look like this: `${expr}`. This also fixes the problem with nested dicts in variable expressions.
- it's now possible to configure the variable blocks to look the same as the block delimiters. Thus you can set the syntax to something like `{ / }` for both blocks and variables.
- added whitespace management system for the template designer.
- some small bugfixes.
- improved security system regarding function calls and variable assignment in for loops.
- added lipsum function to generate random text.
- strings without unicode characters are processed as binary strings now to workaround problems with datetime.strftime which only accepts binary strings.
- it's now possible to use newlines in string literals
- developer friendly traceback is now toggleable
- the variable failure is now pluggable by replacing the undefined singleton for an environment instance
- fixed issue with old-style classes not implementing __getitem__ (thanks to Axel Böhm for discovering that bug)
- added a bunch of new docstrings to the Jinja classes. Makes fun now to use pydoc :-)
- fixed severe memcaching bug. Formerly it wasn't possible to use memcaching without enabling disk cache.
- fixed a bug that allowed users to override the special names _, true etc.
- added batch and slice filters for batching or slicing sequences
- added sum, abs, round and sort filters. This fixes #238
- added striptags and xmlattr filters for easier SGML/XML processing
- the trans tag does not need explicit naming for variables with the same name any more. You can now use `{% trans foo %}` instead of the verbose version `{% trans foo=foo %}`.
- reimplemented Buffet plugin so that it works at least for pylons
- added Environment.get_translations_for_string
- fixed a bug in the parser that didn't unescape keyword arguments. (thanks to Alexey Melchakov for reporting)
- You can now use the environment to just tokenize a template. This can be useful for syntax highlighting or other purposes.
- added optional C-implementation of the context baseclass.
- you can now use optional parentheses around macro defintions. Thus it's possible to write `{% macro foo(a, b, c) %}` instead of `{% macro foo a, b, c %}`.
- additional macro arguments now end up in varargs.
- implemented the {% call %} block. call and endcall can still be used as identifiers until Jinja 1.3
- it's now possible to stream templates.
- fixed a corner case when defining a block inside of a condition
- the cached loader mixin is now able to cache multiple templates from different loaders in the same cache folder.
- Translatable strings returned by `_()` will leave their string formatting signs untouched. Thanks to Stefan Ebner for reporting.
- `{% block name "data" %}` is now an alias for `{% block name %}data{% endblock %}`. Note that the second argument can be an expression. As soon as you specify an expression as second argument the closing tag has to be omitted.
- It's now possible to iterate over iterators additionally to sequences. If the iterator is inifite it will crash however, so makes sure you don't pass something like that to a template!
- added rendetemplate to render included templates in an isolated environment and get the outout back.
- added simplefilter decorator.
- improved ChoiceLoader error reporting (thanks to Bryan McLemore)
- fixed extended slicing
- reworked loader layer. All the cached loaders now have "private" non cached baseclasses so that you can easily mix your own caching layers in.
- added MemcachedLoaderMixin and MemcachedFileSystemLoader contributed by Bryan McLemore.

## Version 1.0

(codename: siyutusan, released Mar 23, 2007)

- Initial release