evoque

One indication of size is the SLOC count -- for Evoque the installed runtime package is made up of 992 SLOC, while for Mako 0.2.4 it is 3552 SLOC [b].

Another indication of size is the number of keywords. Evoque collectively calls these directives and defines 7 of them. By contrast, Mako calls these control structures and tags and defines a total of 11 of them. Yet, as far as capability is concerned, there is in practice nothing that can be done with Mako's 11 constructs that may not be done with Evoque's 7 directives. The opposite seems to not be true however e.g. there seems to be no Mako equivalent to Evoque's test directive.

Beyond the template constructs, that same small number of SLOC also offers other major capabilities (e.g. sandbox support, all the other unique features below) that Mako and other systems do not offer.

Small is of course naturally accompanied by simple, easy to remember, easy to use.

Evoque is constructed on the quoted-no-more string type pattern, and a string type to take care of automatic once-only quoting of xml/html output is provided by default. An application may extend this behaviour to any output format by adding custom quoted-no-more classes.

An Evoque template needs no modifications to be used as a base template i.e. a base template is perfectly functional and usable as a template in its own right, just as well as any template that inherits from it (called an overlay in Evoque parlance). In contrast, super and sub templates in Mako must make explicit inheritance-specific calls e.g. next(), body() and parent() -- possibly making them unusable outside of the inheritance chain, as well as causing problems in cases when we need to inherit from a template for which we do not have write permission.

Unique to Evoque is the concept of positive and negative template space and an inheriting template, or overlay, may choose to override either one or the other.

All controls structures and directives may be specified liberally over single or multiple lines. This has benefits such as allowing an inlined if/elif/else or an inlined for loop (or even a combination of the two) to calculate for example the value of an HTML attribute, just as easily as multi-line if/elif/else or for blocks to control which section of a template gets rendered. Evoque makes no assumptions about whether a directive (or combination of directives) should occupy an entire line, be part of a line, or span several lines -- such constraints belong exclusively to the targeted output format.

Evoque logic in templates is specified with directives and expressions. Syntactically these are the same -- the only difference is that a directive has an additional qualifying keyword between the initial $ and the opening { or {% delimiter -- making the syntax consistent and easy to remember. In contrast, Mako has a different syntax for each type of construct:
- control structures: % if x==5:\n,
- tags: <%inherit>,
- code blocks: <% return %>,
- expressions: ${x}.

An open-ended mechanism to conditionally intercept input and/or output of any directive or expression and do something with it -- but with the possibility of turning it on and off depending on the context. The syntax is consistent for both directives and expressions:
$directive[ condition ? decorator(*args) ]{ ... }
$[ condition ? decorator(*args) ]{ ... }
and when condition evaluates to True, the evaluation of the directive/expression is decorated, while when condition evaluates to False the decorator is compiled out of the loaded template, thus rendering performance is categorically not affected. Use cases include expression/block level output caching, validation, etc. Not yet available.

A template may declare multiple test data scenarios that it should be able to handle.

Expressions may take advantage of all formatting options allowed by python's string formating operations.

Surprisingly rare! Nested comments are very convenient, in particular during development, for commenting out entire blocks of template source that may contain other comments.

Evoque's template caching supports an auto_reload:int=60 parameter to set the minimum number of seconds to wait between file-system checks -- other template systems typically just offer a flag whether to do the file-system check or not, on each request.

Some template engines pride themselves with being pythonic, to the extent of even imposing such pythonicities as template source indentation! Evoque leaves how template source code should be formatted entirely to the liberty of the target output format. If you want your templates to look really pythonic, it is easy enough to write python directly, or to use a slightly modified more convenient python syntax such as that offered by Qpy Templates.

Usage of evoque is not cluttered by underlying implementation details i.e. you do not need to be aware of any runtime implementation details. This is in contrast to other systems that sometimes require you to explicitly workaround some internal detail. For example, to maximize performance Mako plays some tricks with its internal buffering, requiring you in some cases to specify things like buffered="True" to get the output you expect. Actually, generated output in Evoque is internally always buffered, with the performance being none the less than Mako's.

Since version 0.4 released on 21 January 2009 the same Evoque code base runs also on Python 3.0, probably making Evoque the first full-featured templating engine to be available for Python 3.0.