This library is an attempt to implement Jinja2 template engine on D language.
- Statements
{%...%} - Expressions
{{...}} - Comments
{#...#} - Line statements
#, comments##
- Variable itself:
foo - Variable's field:
foo.barorfoo['bar'] - Variables array:
foos[2]
- Integer number:
42 - Floating number
42.2 - String:
"Some string",'Another string' - Boolean:
true/false,True/False - Array:
[1, 'string', false] - List:
(1, 'string', false)note: internal list representation still is array - Dictionary:
{'a': 10, 'b': true}or{a: 10, b: true}note: keys in dictionary can only be strings - Math Operators:
**,*,/,//,%,+,- - Logic operators:
(...),not,and,or - Comparison operators:
==,!=,>=,<=,>,< - Other operators:
in,is,|,~,...(...) - Ternary if:
... if ... else ...
- If:
if/elif/else/endif - For:
for/else/endfor - Macros:
macro/endmacro - Call:
call/endcall - Set:
set - Filter:
filter - Extending:
extends,block/endblock - Import:
import - Include:
include - With:
with/endwithnote: without assignment
Space control with - operator allowed only for statements: {%- ... -%}
Most of global functions / tests / filters are not implemented at the moment. Must be done later.
- Implemented functions:
range,length/count,namespace - Implemented test:
defined,undefined,number,list,dict - Implemented filters:
default/d,escape/e,upper,sort,keys
Unlike original Jinja it is possible to set variables inside a block and have them show up outside of it. This means that the following example will work as expected.
{% set iterated = false %}
{% for item in seq %} ## non-empty sequence
{{ item }}
{% set iterated = true %}
{% endfor %}
{% if not iterated %} did not iterate {% endif %} ## will not be printed (iterated == true)It is possible to set variable field and member of array:
{% set foo = {} %}
{% set foo.bar = 10 %}
{{ foo.bar }} ## 10{% set foos = [1, 2, 3] %}
{% set foos[2] = 30 %}
{{ foos }} ## [1, 2, 30]It is possible to use Uniform Function Call Syntax for variables like in D:
{% set foo = [1, 1, 1, 1, 1] %}
{{ range(length(foo)) }} ## [0, 1, 2, 3, 4]
{{ foo.length.range }} ## [0, 1, 2, 3, 4]You can return value from user defined macros due to return keyword in endmacro statement:
{% macro sum(numbers) %}
{% sum = 0 %}
{% for num in numbers %}
{% sum = sum + num %}
{% endfor %}
{% endmacro return sum %}
{{ sum([1, 2, 3, 4]) * 10 }} ## 100Since macros can return value, you can use them as functions / filters / tests:
{% macro sum(numbers) %}
{% sum = 0 %}
{% for num in numbers %}
{% sum = sum + num %}
{% endfor %}
{% endmacro return sum %}
{{ [0, 1, 2, 4] | sum | e }} ## 7{% macro large(l) %}
{% endmacro return l is list and l.length > 10 %}
{{ 'yes' if [0, 1, 2] is large else 'no' }} ## noIt is possible to define macro inside another macro and inner macro has link to external contexts.
{% set a = 1 %}
{% macro m1 %} ## variables `a`, `b` are available inside
{% set b = 2 %}
{% macro m2 %} ## variables `a`, `b`, `c` are available inside
{% set c = 3 %}
{% endmcaro %}
{% endmcaro %}{% set counter = 0 -%}
{%- macro inc() -%}
{% set counter = counter + 1 %}
{%- endmacro return counter -%}
{{ inc() }} ## 1
{{ inc() }} ## 2
{{ inc() }} ## 3
{{ inc() }} ## 4string renderData(T...)(string tmpl);Rendering data from the template
Parameters:
T...- aliases for exported variables and functionstmpl- template to be rendered
Returns: rendered template
string renderFile(T...)(string path);Rendering data from the file
Parameters:
T...- aliases for exported variables and functionspath- path to template file
Returns: rendered template
TemplateNode loadData(JinjaConfig config = defaultConfig)(string tmpl);Parsing template from string to AST for further rendering
Parameters:
config- configuration for djinjatmpl- template to be parsed
Returns: parsed template
TemplateNode loadFile(JinjaConfig config = defaultConfig)(string path);Parsing template from file to AST for further rendering via render function
Parameters:
config- configuration for djinjapath- path to template file
Returns: parsed template
string render(T...)(TemplateNode tree);Rendering data from the AST
Parameters:
T...- aliases for exported variables and functionstree- parsed template
Returns: rendered template
Default configuration:
struct JinjaConfig
{
string exprOpBegin = "{{";
string exprOpEnd = "}}";
string stmtOpBegin = "{%";
string stmtOpEnd = "%}";
string cmntOpBegin = "{#";
string cmntOpEnd = "#}";
string cmntOpInline = "##";
string stmtOpInline = "#";
}import std.stdio;
import djinja;
int sum(int a, int b)
{
return a + b;
}
void main()
{
int num = 10;
auto result = renderData!(num, sum)("{{ sum(num, 15) }}");
writeln(result); // 25
}import std.stdio;
import djinja;
int sum(int a, int b)
{
return a + b;
}
void main()
{
enum JinjaConfig conf = { exprOpBegin: "<", exprOpEnd: ">" };
auto ast = loadFile!(conf)("simple.dj"); // simple.dj: "< sum(1, 2) >"
auto result = render!(sum)(ast);
writeln(result); // 3
}- Make a wrapper for UniNode that allows using macros as passed values
- Add flag to config allowing override set behavior to its original one
- Extend whitespace control behavior
- Add more tests