jinja2 macros vs jsp2.0标签

Question

I am a java programmer learning python/jinja .

My biggest beef with jinja2 macros is the limitation of having a single caller(). for example, i could do the following in jsp2 tags:

tag def:

<% attribute name="title" fragment="true">
<div class='title'>${title}</div>
<div class='body'><jsp:doBody/></div>

usage:

<myTag>
  <jsp:attribute name='title'>
    <c:if test='${blah}'>This is only here sometimes</c:if>
  </jsp:attribute>
  <jsp:body>
    <c:if test='${something}'>some dynamic content</c:if>
  </jsp:body>
</myTag>

what i want to stress here, is that both the body content and the 'title' attribute have content that is dynamic . also, there are no hacks here of setting variables to dynamic content and passing them in.

now lets look at a jinja macro that does the same thing:

{% macro myTag(title='', caller) -%}
  <div class='title'>{{ title }}</div>
  <div class='body'>{{ caller() }}</div>
{%- endmacro %}

but wait! i cannot easily put dynamic content into the title attribute!

{% call myTag(title='imagine putting some content here that involves 5 loops, 4 ifs and whatnot?') %}
   {% if something %}some dynamic content{% endif %}
{% endcall %}

is this a problem with my being a newbie, or is this a shortcoming of jinja?

Answer 1

So in fact this is a core feature of Mako Templates for Python . It's not as widely used of a feature but it's important to me, as it's pretty critical in custom template tags as you mention, so it's there:

http://www.makotemplates.org/docs/defs.html#calling-a-def-with-embedded-content-and-or-other-defs

JSP is one of several template systems Mako draws inspiration from.

Answer 2

In addition to hack suggested by dave you can pass local macro result to any other macro. This is especially useful when you don't know in advance will be passed parameter defined locally or it will come from template variable:

{% macro doTag(title, body) %}
<div class='title'>{{ title }}</div>
<div class='body'>{{ body }}</div>
{% endmacro %}


{% macro tagBody() %}
{% if something %}some dynamic content{% endif %}
{% endmacro %}

{{ doTag(title='some simple title', body=tagBody() }}

{% macro tagTitle() %}
content here that involves 5 loops, 4 ifs
{% endmacro %}

{{ doTag(title=doTitle(), body=tagBody() }}

Answer 3

So you're right in that you can't pass multiple blocks. However, you can pass a variable back to the caller, which it can act upon. Therefore, you can do something like this:

{% macro test() %}
{{ caller('a') }}
{{ caller('b') }}
{% endmacro %}

{% call(which) test() %}
{% if which == 'a' %}hello
{% elif which == 'b' %}world
{% endif %}
{% endcall %}

To describe that in more detail, call(which) defines a caller that takes one argument, which . When the macro refers to the caller, it passes to the caller an identifier for the block of content it actually wants the caller to return. The caller can then act upon this.

It's not elegant or fool proof, but it works.

Answer 4

and now there is a better solution:

http://mankyd.github.com/jinjatag/