Jingoo - Template designer documentation

Loop over each item in a sequence.

Inside of a for-loop block, you can access some special variables:

loop.index: The current iteration of the loop. (1 indexed)
loop.index0: The current iteration of the loop. (0 indexed)
loop.revindex: The number of iterations from the end of the loop (1 indexed)
loop.revindex0: The number of iterations from the end of the loop (0 indexed)
loop.first: True if first iteration.
loop.last: True if last iteration.
loop.length: The number of items in the sequence.
loop.cycle: A helper function to cycle between a list of sequences.

MODELS JINGOO RESULT

{{ { links: [ [ "http://yahoo.co.jp", "yahoo japan" ],
	      [ "http://google.co.jp", "google japan" ] ],
     links2:[ ("http://yahoo.co.jp", "yahoo japan"),
              ("http://google.co.jp", "google japan") ],
     obj: { name: "alice", age: 42, sex: "F" },
     str1: "abc",
     str2: "日本語"
   } }}

{%- for item in [ 0, 1, 2, 3, 4, 5 ] -%}
  - {{ item }}: {{ loop.cycle (["even","odd"]) }}
{% endfor -%}
{%- for item in links -%}
<a href="{{ item[0] }}">{{ item[1] }}</a>
{% endfor -%}
{%- for (href, title) in links2 -%}
<a href="{{ href }}">{{ title }}</a>
{% endfor -%}
{%- for (key, value) in obj -%}
  - {{ key }}: {{ value }}
{% endfor -%}
{% for s in str1 -%}
  {{ s }}({{ loop.index }})
{% endfor -%}
{% for s in str2 -%}
{{ s }}({{ loop.index }})
{% endfor -%}

- 0: even
- 1: odd
- 2: even
- 3: odd
- 4: even
- 5: odd
<a href="http://yahoo.co.jp">yahoo japan</a>
<a href="http://google.co.jp">google japan</a>
<a href="http://yahoo.co.jp">yahoo japan</a>
<a href="http://google.co.jp">google japan</a>
- name: alice
- age: 42
- sex: F
a(1)
b(2)
c(3)
日(1)
本(2)
語(3)

Macro are useful to put often used idioms into reusable component.

Note that macros are hoisted, and their scope is the toplevel scope. It means that you define two macro with the same name, the second will erase the first, even in the macro invocation occuring before the second definition.

Optionally, you can repeat the name of the macro in the endmacro part.

Use call statement to pass a macro to another macro.

Function can be seen as macros that return a value instead of printing it.

JINGOO RESULT

{% function incr (i) %}{{i+1}}{% endfunction -%}
incr(1) = {{ incr (1) }}
incr(-1) = {{ incr (-1) }}

{% function lt1 (i) %}{{ i < 1 }}{% endfunction -%}
lt1(1) = {{ lt1 (1) }}
lt1(-1) = {{ lt1 (-1) }}

{% function obj (x, y) %}{{ {a:x,b:y} }}{% endfunction -%}

obj(1,2).a = {{ obj(1,2).a }}
obj(1,2).b = {{ obj(1,2).b }}

obj('a',2.5).a = {{ obj('a',2.5).a }}
obj('a',2.5).b = {{ obj('a',2.5).b }}

{% function inv (reverse=false, x, y) -%}
  {%- if reverse %}{{ {a:y,b:x} }}{% else %}{{ {a:x,b:y} }}{% endif -%}
{%- endfunction -%}

inv('a','b').a = {{ (inv('a','b')).a }}
inv(reverse=true,'a','b').a = {{ (inv(reverse=true,'a','b')).a }}

{% function add_val (val=0, x) -%}
  {{ [ x, (x + val) ] }}
{%- endfunction -%}
{% for x in [-1,0,1,2] | map (add_val, val=-2) -%}
  add_val(val=-2,{{x[0]}}) = {{x[1]}}
{% endfor -%}

{% function const () -%}{{ 4 }}{% endfunction -%}

const() = {{ const () }}

incr(1) = 2
incr(-1) = 0

lt1(1) = false
lt1(-1) = true

obj(1,2).a = 1
obj(1,2).b = 2

obj('a',2.5).a = a
obj('a',2.5).b = 2.5

inv('a','b').a = a
inv(reverse=true,'a','b').a = b

add_val(val=-2,-1) = -3
add_val(val=-2,0) = -2
add_val(val=-2,1) = -1
add_val(val=-2,2) = 0
const() = 4

The if statement allows us to check if an expression is true or false, and execute different code according to the result.

0, null, '', "", [], or {} are considered as false when used in a if/elif test. The rest is true.

The switch statement allows us to use compare a variable with a set of literal values.

All blocks introduce a new scope when assigning variables. You can read a variable defined in a parent block, but you can not assign a new value to this variable. A new variable will be created for each assignment. It will shadow the old definition, but as soon as you will leave the block, the old definition

The only exception to that rule are if statements which do not introduce a scope.

See Namespace for variable assignement propagating across scopes.

Namespace are used to create variables you can modify from a child block.

Use {%- to strip whitespaces before this token.

Use -%} to strip whitespaces after this token.

Tests can be used with the standard function call syntax, but also with the is keyword in statements or expressions.

Evaluation of boolean operators is sequential, left-to-right.

In e1 && e2, e1 is evaluated first, and if it returns false, e2 is not evaluated at all.

In e1 || e2, e1 is evaluated first, and if it returns true, e2 is not evaluated at all.

Use not and ! operators to negate a boolean.

The fat arrow operator => is used to define anonymous functions.

It is right associative and have the lowest precedence of all the operators.