Grantlee: Extending the template system

Grantlee 5.3.0

Extending the template system

# Filter and tag Libraries

As already noted, it is possible for application developers to create their own tags and filters. This feature is based on the QtPlugin system so that plugins can be loaded at run time.

Note
  If you are already familiar with Django, you will know that this is not necessary on that system. That is because Django libraries are just python modules, which can behave like dynamically loaded plugins.

## Filters

A filter takes an object and an optional argument and returns a string. To create your own filter, create a concrete subclass of Grantlee::Filter and implement the Filter::doFilter method.

class TwiceFilter : public Grantlee::Filter
{
QVariant dofilter(const QVariant &input, const QVariant &arg = QVariant(), bool autoescape = false) const override
{
auto str = getSafeString(input);
return str + str;
}
bool isSafe() const override { return true; } // see the Autoescaping section
};
...
Seeing double {{ name|twice }}?
// Renders: Seeing double MikeMike?
Grantlee::Filter
Base class for all filters.
Definition filter.h:60

The argument to doFilter is a QVariant, so it may contain any of the types supported by Grantlee.

class RepeatFilter : public Grantlee::Filter
{
QVariant dofilter(const QVariant &input, const QVariant &arg = QVariant(), bool autoescape = false) const override
{
auto str = getSafeString(input);
if ( arg.type() != QMetaType::Int )
return str; // Fail gracefully.
auto times = arg.toInt();
for (int i = 0; i < times ++i)
{
str.get().append(str);
}
return str;
}
bool isSafe() const { return true; }
};
...
Seeing more {{ name|repeat:"3" }}?
// Renders: Seeing more NathalieNathalieNathalie?
Seeing more {{ name|repeat:"four" }}?
// Renders: Seeing more Otto? (failing gracefully)

Note that the filter does not fail or throw an exception if the integer conversion fails. Filters should handle all errors gracefully. If an error occurs, return either the input, or an empty string. Whichever is more appropriate.

# Autoescaping and safe-ness

When implementing filters, it is necessary to consider whether string output from the template should be escaped by Grantlee when rendering the template. Grantlee features an autoescaping feature which ensures that a string which should only be escaped once is not escaped two or more times.

See also
  Autoescaping in templates.

The filter interface contains two elements relevant to autoescaping. The first is the `autoescape` parameter to the Filter::doFilter method. The `autoescape` parameter indicates the current autoescaping state of the renderer, which can be manipulated in templates with the `{% autoescape %}` tag. Use of the `autoescape` parameter is rare. The second element of autoescaping in the Filter API is the Filter::isSafe method. This method can be reimplemented to indicate that a Filter is 'safe' - that is - if given safe input, it produces safe output.

See also
  http://docs.djangoproject.com/en/dev/howto/custom-template-tags/#filters-and-auto-escaping
  http://groups.google.com/group/django-users/browse_thread/thread/311f336d74e7b643

## Tags

A tag can really do anything with a template. To create your own tag, create a concrete subclass of Grantlee::AbstractNodeFactory and implement the AbstractNodeFactory::getNode method, and create a concrete subclass of Grantlee::Node and implement the Node::render method.

Note
  If you are familiar with Django you will recognise that defining a tag in Django involves creating a Node subclass (like Grantlee), and a factory function where Grantlee requires a factory class. This is because functions in python are objects, just like classes are, and dynamic typing allows easy creation of lists of those factory functions. In Grantlee with statically-typed C++, we need to group the factories by interface (i.e, the Grantlee::AbstractNodeFactory interface).

Tags can take arguments, advance the parser, create nodes, and generally have broad control over the parsing and rendering stages.

Here is an example of a `{% current_time %}` tag which displays the current time.

class CurrentTimeNode : public Grantlee::Node
{
Q_OBJECT
public:
CurrentTimeNode( QObject *parent = {} )
: Grantlee::Node( parent )
{
}
void render( Grantlee::OutputStream *stream, Grantlee::Context *c) const override
{
Q_UNUSED(c);
(*stream) << QDateTime::currentDateTime().toString();
}
};
class CurrentTimeTagFactory : public Grantlee::AbstractNodeFactory
{
Grantlee::Node *getNode(const QString &tagContent, Grantlee::Parser *p) const override
{
Q_UNUSED(p);
// You almost always want to use smartSplit.
QStringList parts = smartSplit(tagContent);
parts.removeFirst(); // Not interested in the name of the tag.
if (!parts.isEmpty())
// The remaining parts are the arguments to the tag. If an incorrect number of arguments
// is supplied, and exception should be thrown.
throw Grantlee::Exception( Grantlee::TagSyntaxError, "current_time does not take any arguments" );
return new CurrentTimeNode();
}
};
Grantlee::AbstractNodeFactory
Base class for all NodeFactories.
Definition node.h:305
Grantlee::Context
The Context class holds the context to render a Template with.
Definition context.h:118
Grantlee::Exception
An exception for use when implementing template tags.
Definition exception.h:85
Grantlee::Node
Base class for all nodes.
Definition node.h:83
Grantlee::OutputStream
The OutputStream class is used to render templates to a QTextStream.
Definition outputstream.h:81
Grantlee::Parser
The Parser class processes a string template into a tree of nodes.
Definition parser.h:49
Grantlee
The Grantlee namespace holds all public Grantlee API.
Definition Mainpage.dox:8

See also
  AbstractNodeFactory::smartSplit

Note
  The current_time tag could be extended to format the time in a particular way. That is the behaviour of the `{% now %}` tag. See its documentation and implementation for details.

Also, note that, AbstractNodeFactory::getNode implementation may throw an execption at template compilation time, but like implementations of Filter::doFilter, implememtations of Node::render should return an empty QString in most error cases.

## Tags with end tags

Often, tags will be not just one token in a template, but a start and end token such as `range`, `spaceless`, `with`, or a start, middle and end tokens, such as `if` and `for`.

When constructing a Node, a AbstractNodeFactory implementation can instruct the Parser to parse until any appropriate Token.

text content
{% if foo %}
foo content
{% else %}
default content
{% endif %}
end content

To implement such a tag the implementation of AbstractNodeFactory::getNode needs to parse until the optional intermediate tags and until the mandatory end tag, collecting the child nodes as it does so.

Node* IfNodeFactory::getNode( const QString &tagContent, Parser *p ) const override
{
QStringList parts = smartSplit( tagContent );
parts.removeFirst(); // Remove "if"
// Error handling etc.
auto argsList = getFilterExpressionList( parts );
auto node = new IfNode( argsList, p );
// Parse until an else or endif token
auto trueList = p->parse( node, QStringList{"else", "endif"} );
node->setTrueList( trueList );
auto falseList;
auto nextToken = p->takeNextToken();
if ( nextToken.content == "else" )
{
falseList = p->parse( node, "endif" );
node->setFalseList( falseList );
// skip past the endif tag
p->removeNextToken();
} // else empty falseList.
return node;
}

There is no limit to the number of intermediate tokens you can use in your tags. For example, a better `{% if %}` tag might support multiple elif tags.

text content
{% if foo %}
foo content
{% elif bar %}
bar content
{% elif bat %}
bat content
{% else %}
default content
{% endif %}
end content

# C++ Libraries

As already mentioned, it is neccessary to create a QtPlugin library to make your tags and filters available to Grantlee. You need to implement TagLibraryInterface to return your custom node factories and filters. See the existing libraries in your Grantlee distribution for full examples.

#include <grantlee/taglibraryinterface.h>
#include "mytag.h"
#include "myfilter.h"
class MyLibrary : public QObject, public Grantlee::TagLibraryInterface
{
Q_OBJECT
Q_INTERFACES( Grantlee::TagLibraryInterface )
public:
MyLibrary(QObject *parent = 0)
: QObject (parent)
{
m_nodeFactories.insert("mytag", new MyNodeFactory());
m_filters.insert("myfilter", new MyFilter());
}
QHash<QString, Grantlee::AbstractNodeFactory*> nodeFactories(const QString &name = QString())
{
Q_UNUSED(name);
return m_nodeFactories;
}
QHash<QString, Grantlee::Filter*> filters(const QString &name = QString())
{
Q_UNUSED(name);
return m_filters;
}
};
Grantlee::TagLibraryInterface
The TagLibraryInterface returns available tags and filters from libraries.
Definition taglibraryinterface.h:80

# Javascript Libraries

If you configure your application to use the grantlee_scriptabletags_library, it will be possible for you and theme writers to write tags and filters in Javascript instead of C++. Themers would have as much control as a C++ plugin writer over those steps of processing and rendering the template.

Writing Javascript plugins is slightly different from writing C++ plugins, and is a bit more like writing Django plugins. Namely, in Javascript like python, functions are first-class objects, and Javascript is dynamically typed. Additionally Javascript plugins are just text files, so they can easily be dynamically loaded at runtime. Javascript files must be UTF-8 encoded.

Here is a complete Javascript library defining an `{% echo %}` tag which outputs its arguments:

var EchoNode = function(content)
{
this.content = content;
this.render = function(context)
{
return content.join(" ");
};
};
function EchoNodeFactory(tagContent, parser)
{
var content = tagContent.split(" ");
content = content.slice(1, content.length);
return new Node("EchoNode", content);
};
EchoNodeFactory.tagName = "echo";
Library.addFactory("EchoNodeFactory");

Some things to note:

- `Library` is a globally accessible object used to register `Factories`.
- The `addFactory` method takes a string which is the name of an object, not the object itself.
- The script factory function returns a `Node`. The first argument to `Node` is the name of the Javascript object in the library which defines the node. All additional arguments will be passed to the constructor of that node.

- The Node function must have a callable render property which takes a context argument.

  Todo
    @section javascript_diff Differences between C++ and Javascript library plugins.

## Loaders

As noted in Creating Templates, you will usually not create a Template directly, but retrieve it from an Engine instance. The Engine allows you to define where the templates are retrieved from when you request them by name.

You can redefine the order of places in the filesystem which are searched for templates, and even define new ways to retrieve templates (i.e, not from the filesystem) by subclassing Grantlee::AbstractTemplateLoader and implementing the AbstractTemplateLoader::loadByName method. For existing loaders, see FileSystemTemplateLoader, InMemoryTemplateLoader, and AkonadiTemplateLoader.