About Jinja2
Jinja2 is a full featured template engine for Python. It has full unicode support, an optional integrated sandboxed execution environment, widely used and BSD licensed.
Other Formats
You can download the documentation in other formats as well:
Useful Links
Jinja2-2.9.5/docs/_templates/sidebarlogo.html 0000644 0000765 0000024 00000000217 12371160734 022254 0 ustar mitsuhiko staff 0000000 0000000
 }})
Related Topics
- Documentation overview
-
{%- for parent in parents %}
- {{ parent.title }}
-
{%- endfor %}
{%- if prev %}
- Previous: {{ prev.title }} {%- endif %} {%- if next %}
- Next: {{ next.title }} {%- endif %} {%- for parent in parents %}
{%- endfor %}
- {{ parent.title }}
%s
' % p.replace('\n', Markup('\n')) for p in _paragraph_re.split(escape(value))) if eval_ctx.autoescape: result = Markup(result) return result Context filters work the same just that the first argument is the current active :class:`Context` rather then the environment. .. _eval-context: Evaluation Context ------------------ The evaluation context (short eval context or eval ctx) is a new object introduced in Jinja 2.4 that makes it possible to activate and deactivate compiled features at runtime. Currently it is only used to enable and disable the automatic escaping but can be used for extensions as well. In previous Jinja versions filters and functions were marked as environment callables in order to check for the autoescape status from the environment. In new versions it's encouraged to check the setting from the evaluation context instead. Previous versions:: @environmentfilter def filter(env, value): result = do_something(value) if env.autoescape: result = Markup(result) return result In new versions you can either use a :func:`contextfilter` and access the evaluation context from the actual context, or use a :func:`evalcontextfilter` which directly passes the evaluation context to the function:: @contextfilter def filter(context, value): result = do_something(value) if context.eval_ctx.autoescape: result = Markup(result) return result @evalcontextfilter def filter(eval_ctx, value): result = do_something(value) if eval_ctx.autoescape: result = Markup(result) return result The evaluation context must not be modified at runtime. Modifications must only happen with a :class:`nodes.EvalContextModifier` and :class:`nodes.ScopedEvalContextModifier` from an extension, not on the eval context object itself. .. autoclass:: jinja2.nodes.EvalContext .. attribute:: autoescape `True` or `False` depending on if autoescaping is active or not. .. attribute:: volatile `True` if the compiler cannot evaluate some expressions at compile time. At runtime this should always be `False`. .. _writing-tests: Custom Tests ------------ Tests work like filters just that there is no way for a test to get access to the environment or context and that they can't be chained. The return value of a test should be `True` or `False`. The purpose of a test is to give the template designers the possibility to perform type and conformability checks. Here a simple test that checks if a variable is a prime number:: import math def is_prime(n): if n == 2: return True for i in xrange(2, int(math.ceil(math.sqrt(n))) + 1): if n % i == 0: return False return True You can register it on the template environment by updating the :attr:`~Environment.tests` dict on the environment:: environment.tests['prime'] = is_prime A template designer can then use the test like this: .. sourcecode:: jinja {% if 42 is prime %} 42 is a prime number {% else %} 42 is not a prime number {% endif %} .. _global-namespace: The Global Namespace -------------------- Variables stored in the :attr:`Environment.globals` dict are special as they are available for imported templates too, even if they are imported without context. This is the place where you can put variables and functions that should be available all the time. Additionally :attr:`Template.globals` exist that are variables available to a specific template that are available to all :meth:`~Template.render` calls. .. _low-level-api: Low Level API ------------- The low level API exposes functionality that can be useful to understand some implementation details, debugging purposes or advanced :ref:`extension
-
{% for user in users %}
- {{ user.username }} {% endfor %}
-
% for item in list:
- ${item} % endfor
-
% for item in list:
- ${item} % endfor
My Webpage
{{ a_variable }} {# a comment #} The following example shows the default configuration settings. An application developer can change the syntax configuration from ``{% foo %}`` to ``<% foo %>``, or something similar. There are a few kinds of delimiters. The default Jinja delimiters are configured as follows: * ``{% ... %}`` for :ref:`Statements
{% if True %}
yay
{% endif %}
gets rendered with blank lines inside the div::
yay
But with both `trim_blocks` and `lstrip_blocks` enabled, the template block
lines are removed and other whitespace is preserved::
yay
You can manually disable the `lstrip_blocks` behavior by putting a
plus sign (``+``) at the start of a block::
{%+ if something %}yay{% endif %}
You can also strip whitespace in templates by hand. If you add a minus
sign (``-``) to the start or end of a block (e.g. a :ref:`for-loop` tag), a
comment, or a variable expression, the whitespaces before or after
that block will be removed::
{% for item in seq -%}
{{ item }}
{%- endfor %}
This will yield all elements without whitespace between them. If `seq` was
a list of numbers from ``1`` to ``9``, the output would be ``123456789``.
If :ref:`line-statements` are enabled, they strip leading whitespace
automatically up to the beginning of the line.
By default, Jinja2 also removes trailing newlines. To keep single
trailing newlines, configure Jinja to `keep_trailing_newline`.
.. admonition:: Note
You must not add whitespace between the tag and the minus sign.
**valid**::
{%- if foo -%}...{% endif %}
**invalid**::
{% - if foo - %}...{% endif %}
Escaping
--------
It is sometimes desirable -- even necessary -- to have Jinja ignore parts
it would otherwise handle as variables or blocks. For example, if, with
the default syntax, you want to use ``{{`` as a raw string in a template and
not start a variable, you have to use a trick.
The easiest way to output a literal variable delimiter (``{{``) is by using a
variable expression::
{{ '{{' }}
For bigger sections, it makes sense to mark a block `raw`. For example, to
include example Jinja syntax in a template, you can use this snippet::
{% raw %}
-
{% for item in seq %}
- {{ item }} {% endfor %}
-
# for item in seq
- {{ item }} # endfor
-
{% for item in seq %}
- {{ item }} {% endfor %}
-
# for href, caption in [('index.html', 'Index'),
('about.html', 'About')]:
- {{ caption }} # endfor
{% block content %}{% endblock %}
In this example, the ``{% block %}`` tags define four blocks that child templates
can fill in. All the `block` tag does is tell the template engine that a
child template may override those placeholders in the template.
Child Template
~~~~~~~~~~~~~~
A child template might look like this::
{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block head %}
{{ super() }}
{% endblock %}
{% block content %}
Index
Welcome to my awesome homepage.
{% endblock %} The ``{% extends %}`` tag is the key here. It tells the template engine that this template "extends" another template. When the template system evaluates this template, it first locates the parent. The extends tag should be the first tag in the template. Everything before it is printed out normally and may cause confusion. For details about this behavior and how to take advantage of it, see :ref:`null-master-fallback`. The filename of the template depends on the template loader. For example, the :class:`FileSystemLoader` allows you to access other templates by giving the filename. You can access templates in subdirectories with a slash:: {% extends "layout/default.html" %} But this behavior can depend on the application embedding Jinja. Note that since the child template doesn't define the ``footer`` block, the value from the parent template is used instead. You can't define multiple ``{% block %}`` tags with the same name in the same template. This limitation exists because a block tag works in "both" directions. That is, a block tag doesn't just provide a placeholder to fill - it also defines the content that fills the placeholder in the *parent*. If there were two similarly-named ``{% block %}`` tags in a template, that template's parent wouldn't know which one of the blocks' content to use. If you want to print a block multiple times, you can, however, use the special `self` variable and call the block with that name::{{ self.title() }}
{% block body %}{% endblock %} Super Blocks ~~~~~~~~~~~~ It's possible to render the contents of the parent block by calling `super`. This gives back the results of the parent block:: {% block sidebar %}Table Of Contents
... {{ super() }} {% endblock %} Named Block End-Tags ~~~~~~~~~~~~~~~~~~~~ Jinja2 allows you to put the name of the block after the end tag for better readability:: {% block sidebar %} {% block inner_sidebar %} ... {% endblock inner_sidebar %} {% endblock sidebar %} However, the name after the `endblock` word must match the block name. Block Nesting and Scope ~~~~~~~~~~~~~~~~~~~~~~~ Blocks can be nested for more complex layouts. However, per default blocks may not access variables from outer scopes:: {% for item in seq %}Members
-
{% for user in users %}
- {{ user.username|e }} {% endfor %}
-
{% for key, value in my_dict.iteritems() %}
- {{ key|e }}
- {{ value|e }} {% endfor %}
-
{% for user in users %}
- {{ user.username|e }} {% else %}
- no users found {% endfor %}
-
{%- for item in sitemap recursive %}
- {{ item.title }} {%- if item.children -%} {%- endif %} {%- endfor %}
-
{% for user in users %}
- {{ user.username|e }} {% endfor %}
{{ input('username') }}
{{ input('password', type='password') }}
If the macro was defined in a different template, you have to :ref:`import{{ title }}
{{ caller() }}
-
{%- for user in users %}
{{ user.username|e }}
{{ caller(user) }}
{%- endfor %}
- {{ user.realname|e }}
- {{ user.description }}
- Realname
- Description
- Username
- {{ forms.input('username') }}
- Password
- {{ forms.input('password', type='password') }}
{{ forms.textarea('comment') }}
Alternatively, you can import specific names from a template into the current namespace:: {% from 'forms.html' import input as input_field, textarea %}- Username
- {{ input_field('username') }}
- Password
- {{ input_field('password', type='password') }}
{{ textarea('comment') }}
Macros and variables starting with one or more underscores are private and cannot be imported. .. versionchanged:: 2.4 If a template object was passed to the template context, you can import from that object. .. _import-visibility: Import Context Behavior ----------------------- By default, included templates are passed the current context and imported templates are not. The reason for this is that imports, unlike includes, are cached; as imports are often used just as a module that holds macros. This behavior can be changed explicitly: by adding `with context` or `without context` to the import/include directive, the current context can be passed to the template and caching is disabled automatically. Here are two examples:: {% from 'forms.html' import input with context %} {% include 'header.html' without context %} .. admonition:: Note In Jinja 2.0, the context that was passed to the included template did not include variables defined in the template. As a matter of fact, this did not work:: {% for box in boxes %} {% include "render_box.html" %} {% endfor %} The included template ``render_box.html`` is *not* able to access `box` in Jinja 2.0. As of Jinja 2.1, ``render_box.html`` *is* able to do so. .. _expressions: Expressions ----------- Jinja allows basic expressions everywhere. These work very similarly to regular Python; even if you're not working with Python you should feel comfortable with it. Literals ~~~~~~~~ The simplest form of expressions are literals. Literals are representations for Python objects such as strings and numbers. The following literals exist: "Hello World": Everything between two double or single quotes is a string. They are useful whenever you need a string in the template (e.g. as arguments to function calls and filters, or just to extend or include a template). 42 / 42.23: Integers and floating point numbers are created by just writing the number down. If a dot is present, the number is a float, otherwise an integer. Keep in mind that, in Python, ``42`` and ``42.0`` are different (``int`` and ``float``, respectively). ['list', 'of', 'objects']: Everything between two brackets is a list. Lists are useful for storing sequential data to be iterated over. For example, you can easily create a list of links using lists and tuples for (and with) a for loop::-
{% for href, caption in [('index.html', 'Index'), ('about.html', 'About'),
('downloads.html', 'Downloads')] %}
- {{ caption }} {% endfor %}
-
{% for user in users %}
- {{ user.username }} {% endfor %} {% for number in range(10 - users|count) %}
- ... {% endfor %}
-
{% for folder in folders %}
- {{ folder|e }} {% endfor %} {% for filename in files %}
- {{ filename|e }} {% endfor %}
{% trans %}Hello {{ user }}!{% endtrans %}
To translate a template expression --- say, using template filters, or by just accessing an attribute of an object --- you need to bind the expression to a name for use within the translation block::{% trans user=user.username %}Hello {{ user }}!{% endtrans %}
If you need to bind more than one expression inside a `trans` tag, separate the pieces with a comma (``,``):: {% trans book_title=book.title, author=author.name %} This is {{ book_title }} by {{ author }} {% endtrans %} Inside trans tags no statements are allowed, only variable tags are. To pluralize, specify both the singular and plural forms with the `pluralize` tag, which appears between `trans` and `endtrans`:: {% trans count=list|length %} There is {{ count }} {{ name }} object. {% pluralize %} There are {{ count }} {{ name }} objects. {% endtrans %} By default, the first variable in a block is used to determine the correct singular or plural form. If that doesn't work out, you can specify the name which should be used for pluralizing by adding it as parameter to `pluralize`:: {% trans ..., user_count=users|length %}... {% pluralize user_count %}...{% endtrans %} It's also possible to translate strings in expressions. For that purpose, three functions exist: - `gettext`: translate a single string - `ngettext`: translate a pluralizable string - `_`: alias for `gettext` For example, you can easily print a translated string like this:: {{ _('Hello World!') }} To use placeholders, use the `format` filter:: {{ _('Hello %(user)s!')|format(user=user.username) }} For multiple placeholders, always use keyword arguments to `format`, as other languages may not use the words in the same order. .. versionchanged:: 2.5 If newstyle gettext calls are activated (:ref:`newstyle-gettext`), using placeholders is a lot easier: .. sourcecode:: html+jinja {{ gettext('Hello World!') }} {{ gettext('Hello %(name)s!', name='World') }} {{ ngettext('%(num)d apple', '%(num)d apples', apples|count) }} Note that the `ngettext` function's format string automatically receives the count as a `num` parameter in addition to the regular parameters. Expression Statement ~~~~~~~~~~~~~~~~~~~~ If the expression-statement extension is loaded, a tag called `do` is available that works exactly like the regular variable expression (``{{ ... }}``); except it doesn't print anything. This can be used to modify lists:: {% do navigation.append('a string') %} Loop Controls ~~~~~~~~~~~~~ If the application enables the :ref:`loopcontrols-extension`, it's possible to use `break` and `continue` in loops. When `break` is reached, the loop is terminated; if `continue` is reached, the processing is stopped and continues with the next iteration. Here's a loop that skips every second item:: {% for user in users %} {%- if loop.index is even %}{% continue %}{% endif %} ... {% endfor %} Likewise, a loop that stops processing after the 10th iteration:: {% for user in users %} {%- if loop.index >= 10 %}{% break %}{% endif %} {%- endfor %} Note that ``loop.index`` starts with 1, and ``loop.index0`` starts with 0 (See: :ref:`for-loop`). With Statement ~~~~~~~~~~~~~~ .. versionadded:: 2.3 The with statement makes it possible to create a new inner scope. Variables set within this scope are not visible outside of the scope. With in a nutshell:: {% with %} {% set foo = 42 %} {{ foo }} foo is 42 here {% endwith %} foo is not visible here any longer Because it is common to set variables at the beginning of the scope, you can do that within the `with` statement. The following two examples are equivalent:: {% with foo = 42 %} {{ foo }} {% endwith %} {% with %} {% set foo = 42 %} {{ foo }} {% endwith %} An important note on scoping here. In Jinja versions before 2.9 the behavior of referencing one variable to another had some unintended consequences. In particular one variable could refer to another defined in the same with block's opening statement. This caused issues with the cleaned up scoping behavior and has since been improved. In particular in newer Jinja2 versions the following code always refers to the variable `a` from outside the `with` block:: {% with a={}, b=a.attribute %}...{% endwith %} In earlier Jinja versions the `b` attribute would refer to the results of the first attribute. If you depend on this behavior you can rewrite it to use the ``set`` tag:: {% with a={} %} {% set b = a.attribute %} {% endwith %} .. admonition:: Extension In older versions of Jinja (before 2.9) it was required to enable this feature with an extension. It's now enabled by default. .. _autoescape-overrides: Autoescape Overrides -------------------- .. versionadded:: 2.4 If you want you can activate and deactivate the autoescaping from within the templates. Example:: {% autoescape true %} Autoescaping is active within this block {% endautoescape %} {% autoescape false %} Autoescaping is inactive within this block {% endautoescape %} After an `endautoescape` the behavior is reverted to what it was before. .. admonition:: Extension In older versions of Jinja (before 2.9) it was required to enable this feature with an extension. It's now enabled by default. Jinja2-2.9.5/docs/tricks.rst 0000644 0000765 0000024 00000006215 12530567002 016770 0 ustar mitsuhiko staff 0000000 0000000 Tips and Tricks =============== .. highlight:: html+jinja This part of the documentation shows some tips and tricks for Jinja2 templates. .. _null-master-fallback: Null-Master Fallback -------------------- Jinja2 supports dynamic inheritance and does not distinguish between parent and child template as long as no `extends` tag is visited. While this leads to the surprising behavior that everything before the first `extends` tag including whitespace is printed out instead of being ignored, it can be used for a neat trick. Usually child templates extend from one template that adds a basic HTML skeleton. However it's possible to put the `extends` tag into an `if` tag to only extend from the layout template if the `standalone` variable evaluates to false which it does per default if it's not defined. Additionally a very basic skeleton is added to the file so that if it's indeed rendered with `standalone` set to `True` a very basic HTML skeleton is added:: {% if not standalone %}{% extends 'master.html' %}{% endif -%}This is the page body.
{% endblock %} Alternating Rows ---------------- If you want to have different styles for each row of a table or list you can use the `cycle` method on the `loop` object::-
{% for row in rows %}
- {{ row }} {% endfor %}
| {{ cell }} | {% endfor %}
-
# for item in range(10)
- ${item} # endfor
-
{% for item in seq %}
- {{ may_break(item) }} {% endfor %}
-
% for item in seq
- ${item} % endfor
-
{%- for item in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if item % 2 == 0 %}
- {{ loop.index }} / {{ loop.length }}: {{ item }} {%- endfor %}
${page_title|e}
| ${cell} | % endfor
{{ page_title }}
| {{ cell }} | {% end %}
{{ page_title }}
| {{ cell }} | {% endfor %}
${page_title|h}
| ${cell} | % endfor
${page_title}
| ${cell} |
$cgi.escape($page_title)
| $cell | #end for
${page_title}
| #{cell} |
$cgi.escape($page_title)
| $cell | #end for
Page Title
| cell |
${page_title}
| ${row[cell]} |
${page_title|e}
| ${testmacro(cell)} | % endfor
{{ article.title }}
{{ article.body|safe }}
- Name
- {% input_field 'name' %}
- {% input_field 'email' %}
- URL
- {% input_field 'url' %}
- Comment
- {% textarea 'comment' %}
- Captcha
- {% input_field 'captcha' %}
RealWorld Benchmark
A less stupid benchmark for Mako and Jinja2 to get an impression how code changes affect runtime performance.
{% block body %}{% endblock %}
${article.title}
${Markup(article.body)}
RealWorld Benchmark
A less stupid benchmark for Mako and Jinja2 to get an impression how code changes affect runtime performance.
${select('*|text()')}
{{ article.title|e }}
{{ article.body }}
- Name
- {{ input_field('name') }}
- {{ input_field('email') }}
- URL
- {{ input_field('url') }}
- Comment
- {{ textarea('comment') }}
- Captcha
- {{ input_field('captcha') }}
RealWorld Benchmark
A less stupid benchmark for Mako and Jinja2 to get an impression how code changes affect runtime performance.
{% block body %}{% endblock %}
${article.title|h}
${article.body}
- Name
- ${input_field('name')}
- ${input_field('email')}
- URL
- ${input_field('url')}
- Comment
- ${textarea('comment')}
- Captcha
- ${input_field('captcha')}
RealWorld Benchmark
A less stupid benchmark for Mako and Jinja2 to get an impression how code changes affect runtime performance.
${self.body()}
{% endwith %}
{% debug %}
{% blocktrans with book|title as book_t and author|title as author_t %}
This is {{ book_t }} by {{ author_t }}
{% endblocktrans %}
{% blocktrans count list|length as counter %}
There is only one {{ name }} object.
{% plural %}
There are {{ counter }} {{ name }} objects.
{% endblocktrans %}
{% blocktrans with name|escape as name count list|length as counter %}
There is only one {{ name }} object.
{% plural %}
There are {{ counter }} {{ name }} objects.
{% endblocktrans %}
{% blocktrans %}This string will have {{ value }} inside.{% endblocktrans %}
{% trans "This is the title." %}
{% regroup people by gender as grouped %} {% endblock %} Jinja2-2.9.5/ext/django2jinja/templates/layout.html 0000644 0000765 0000024 00000000157 12371160734 023353 0 ustar mitsuhiko staff 0000000 0000000
{% block page-body %}{% endblock %}
Jinja2-2.9.5/ext/django2jinja/templates/subtemplate.html 0000644 0000765 0000024 00000000015 12371160734 024354 0 ustar mitsuhiko staff 0000000 0000000 Hello World!
Jinja2-2.9.5/ext/djangojinja2.py 0000644 0000765 0000024 00000005665 12530567002 017531 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
djangojinja2
~~~~~~~~~~~~
Adds support for Jinja2 to Django.
Configuration variables:
======================= =============================================
Key Description
======================= =============================================
`JINJA2_TEMPLATE_DIRS` List of template folders
`JINJA2_EXTENSIONS` List of Jinja2 extensions to use
`JINJA2_CACHE_SIZE` The size of the Jinja2 template cache.
======================= =============================================
:copyright: (c) 2009 by the Jinja Team.
:license: BSD.
"""
from itertools import chain
from django.conf import settings
from django.http import HttpResponse
from django.core.exceptions import ImproperlyConfigured
from django.template.context import get_standard_processors
from django.template import TemplateDoesNotExist
from jinja2 import Environment, FileSystemLoader, TemplateNotFound
from jinja2.defaults import DEFAULT_NAMESPACE
# the environment is unconfigured until the first template is loaded.
_jinja_env = None
def get_env():
"""Get the Jinja2 env and initialize it if necessary."""
global _jinja_env
if _jinja_env is None:
_jinja_env = create_env()
return _jinja_env
def create_env():
"""Create a new Jinja2 environment."""
searchpath = list(settings.JINJA2_TEMPLATE_DIRS)
return Environment(loader=FileSystemLoader(searchpath),
auto_reload=settings.TEMPLATE_DEBUG,
cache_size=getattr(settings, 'JINJA2_CACHE_SIZE', 400),
extensions=getattr(settings, 'JINJA2_EXTENSIONS', ()))
def get_template(template_name, globals=None):
"""Load a template."""
try:
return get_env().get_template(template_name, globals=globals)
except TemplateNotFound, e:
raise TemplateDoesNotExist(str(e))
def select_template(templates, globals=None):
"""Try to load one of the given templates."""
env = get_env()
for template in templates:
try:
return env.get_template(template, globals=globals)
except TemplateNotFound:
continue
raise TemplateDoesNotExist(', '.join(templates))
def render_to_string(template_name, context=None, request=None,
processors=None):
"""Render a template into a string."""
context = dict(context or {})
if request is not None:
context['request'] = request
for processor in chain(get_standard_processors(), processors or ()):
context.update(processor(request))
return get_template(template_name).render(context)
def render_to_response(template_name, context=None, request=None,
processors=None, mimetype=None):
"""Render a template into a response object."""
return HttpResponse(render_to_string(template_name, context, request,
processors), mimetype=mimetype)
Jinja2-2.9.5/ext/inlinegettext.py 0000644 0000765 0000024 00000005077 12371160734 020055 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Inline Gettext
~~~~~~~~~~~~~~
An example extension for Jinja2 that supports inline gettext calls.
Requires the i18n extension to be loaded.
:copyright: (c) 2009 by the Jinja Team.
:license: BSD.
"""
import re
from jinja2.ext import Extension
from jinja2.lexer import Token, count_newlines
from jinja2.exceptions import TemplateSyntaxError
_outside_re = re.compile(r'\\?(gettext|_)\(')
_inside_re = re.compile(r'\\?[()]')
class InlineGettext(Extension):
"""This extension implements support for inline gettext blocks::
_(Welcome)
_(This is a paragraph)
Requires the i18n extension to be loaded and configured. """ def filter_stream(self, stream): paren_stack = 0 for token in stream: if token.type is not 'data': yield token continue pos = 0 lineno = token.lineno while 1: if not paren_stack: match = _outside_re.search(token.value, pos) else: match = _inside_re.search(token.value, pos) if match is None: break new_pos = match.start() if new_pos > pos: preval = token.value[pos:new_pos] yield Token(lineno, 'data', preval) lineno += count_newlines(preval) gtok = match.group() if gtok[0] == '\\': yield Token(lineno, 'data', gtok[1:]) elif not paren_stack: yield Token(lineno, 'block_begin', None) yield Token(lineno, 'name', 'trans') yield Token(lineno, 'block_end', None) paren_stack = 1 else: if gtok == '(' or paren_stack > 1: yield Token(lineno, 'data', gtok) paren_stack += gtok == ')' and -1 or 1 if not paren_stack: yield Token(lineno, 'block_begin', None) yield Token(lineno, 'name', 'endtrans') yield Token(lineno, 'block_end', None) pos = match.end() if pos < len(token.value): yield Token(lineno, 'data', token.value[pos:]) if paren_stack: raise TemplateSyntaxError('unclosed gettext expression', token.lineno, stream.name, stream.filename) Jinja2-2.9.5/ext/jinja.el 0000644 0000765 0000024 00000011175 12371160734 016231 0 ustar mitsuhiko staff 0000000 0000000 ;;; jinja.el --- Jinja mode highlighting ;; ;; Author: Georg Brandl ;; Copyright: (c) 2009 by the Jinja Team ;; Last modified: 2008-05-22 23:04 by gbr ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Commentary: ;; ;; Mostly ripped off django-mode by Lennart Borgman. ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; This program is free software; you can redistribute it and/or ;; modify it under the terms of the GNU General Public License as ;; published by the Free Software Foundation; either version 2, or ;; (at your option) any later version. ;; ;; This program is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;; General Public License for more details. ;; ;; You should have received a copy of the GNU General Public License ;; along with this program; see the file COPYING. If not, write to ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth ;; Floor, Boston, MA 02110-1301, USA. ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;; Code: (defconst jinja-font-lock-keywords (list ; (cons (rx "{% comment %}" (submatch (0+ anything)) ; "{% endcomment %}") (list 1 font-lock-comment-face)) '("{# ?\\(.*?\\) ?#}" . (1 font-lock-comment-face)) '("{%-?\\|-?%}\\|{{\\|}}" . font-lock-preprocessor-face) '("{#\\|#}" . font-lock-comment-delimiter-face) ;; first word in a block is a command '("{%-?[ \t\n]*\\([a-zA-Z_]+\\)" . (1 font-lock-keyword-face)) ;; variables '("\\({{ ?\\)\\([^|]*?\\)\\(|.*?\\)? ?}}" . (1 font-lock-variable-name-face)) ;; keywords and builtins (cons (rx word-start (or "in" "as" "recursive" "not" "and" "or" "if" "else" "import" "with" "without" "context") word-end) font-lock-keyword-face) (cons (rx word-start (or "true" "false" "none" "loop" "self" "super") word-end) font-lock-builtin-face) ;; tests '("\\(is\\)[ \t]*\\(not\\)[ \t]*\\([a-zA-Z_]+\\)" (1 font-lock-keyword-face) (2 font-lock-keyword-face) (3 font-lock-function-name-face)) ;; builtin filters (cons (rx "|" (* space) (submatch (or "abs" "batch" "capitalize" "capture" "center" "count" "default" "dformat" "dictsort" "e" "escape" "filesizeformat" "first" "float" "format" "getattribute" "getitem" "groupby" "indent" "int" "join" "jsonencode" "last" "length" "lower" "markdown" "pprint" "random" "replace" "reverse" "round" "rst" "slice" "sort" "string" "striptags" "sum" "textile" "title" "trim" "truncate" "upper" "urlencode" "urlize" "wordcount" "wordwrap" "xmlattr"))) (list 1 font-lock-builtin-face)) ) "Minimal highlighting expressions for Jinja mode") (define-derived-mode jinja-mode nil "Jinja" "Simple Jinja mode for use with `mumamo-mode'. This mode only provides syntax highlighting." ;;(set (make-local-variable 'comment-start) "{#") ;;(set (make-local-variable 'comment-end) "#}") (setq font-lock-defaults '(jinja-font-lock-keywords))) ;; mumamo stuff (when (require 'mumamo nil t) (defun mumamo-chunk-jinja3 (pos max) "Find {# ... #}" (mumamo-quick-chunk-forward pos max "{#" "#}" 'borders 'jinja-mode)) (defun mumamo-chunk-jinja2 (pos max) "Find {{ ... }}" (mumamo-quick-chunk-forward pos max "{{" "}}" 'borders 'jinja-mode)) (defun mumamo-chunk-jinja (pos max) "Find {% ... %}" (mumamo-quick-chunk-forward pos max "{%" "%}" 'borders 'jinja-mode)) ;;;###autoload (define-mumamo-multi-major-mode jinja-html-mumamo "Turn on multiple major modes for Jinja with main mode `html-mode'. This also covers inlined style and javascript." ("Jinja HTML Family" html-mode (mumamo-chunk-jinja mumamo-chunk-jinja2 mumamo-chunk-jinja3 mumamo-chunk-inlined-style mumamo-chunk-inlined-script mumamo-chunk-style= mumamo-chunk-onjs= ))) ;;;###autoload (define-mumamo-multi-major-mode jinja-nxhtml-mumamo "Turn on multiple major modes for Jinja with main mode `nxhtml-mode'. This also covers inlined style and javascript." ("Jinja nXhtml Family" nxhtml-mode (mumamo-chunk-jinja mumamo-chunk-jinja2 mumamo-chunk-jinja3 mumamo-chunk-inlined-style mumamo-chunk-inlined-script mumamo-chunk-style= mumamo-chunk-onjs= ))) ) (provide 'jinja) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; jinja.el ends here Jinja2-2.9.5/ext/Vim/ 0000755 0000765 0000024 00000000000 13043126727 015343 5 ustar mitsuhiko staff 0000000 0000000 Jinja2-2.9.5/ext/Vim/jinja.vim 0000644 0000765 0000024 00000013005 12555216373 017156 0 ustar mitsuhiko staff 0000000 0000000 " Vim syntax file " Language: Jinja template " Maintainer: Armin Ronacher-
{% for user in users %}
- {{ user.username }} {% endfor %}
-
...
{%- for column in items|slice(3) %}
If you pass it a second argument it's used to fill missing
values on the last iteration.
"""
seq = list(value)
length = len(seq)
items_per_slice = length // slices
slices_with_extra = length % slices
offset = 0
for slice_number in range(slices):
start = offset + slice_number * items_per_slice
if slice_number < slices_with_extra:
offset += 1
end = offset + (slice_number + 1) * items_per_slice
tmp = seq[start:end]
if fill_with is not None and slice_number >= slices_with_extra:
tmp.append(fill_with)
yield tmp
def do_batch(value, linecount, fill_with=None):
"""
A filter that batches items. It works pretty much like `slice`
just the other way round. It returns a list of lists with the
given number of items. If you provide a second parameter this
is used to fill up missing items. See this example:
.. sourcecode:: html+jinja
-
{%- for item in column %}
- {{ item }} {%- endfor %}
| {{ column }} | {%- endfor %}
-
{% for group in persons|groupby('gender') %}
- {{ group.grouper }}
-
{% for person in group.list %}
- {{ person.first_name }} {{ person.last_name }} {% endfor %}
{% endfor %}
-
{% for grouper, list in persons|groupby('gender') %}
...
{% endfor %}