sheet - templates django settings

Handlebars.js en plantillas Django

Question

Necesito un sistema de plantillas javascript y creo que handlebars.js hace un trabajo excelente en este caso. Tengo conflictos de sintaxis con las plantillas de manillares dentro de una plantilla de django porque django intenta generar variables de manillares.

¿Hay una etiqueta en las plantillas de django para dejar de representar un bloque con llaves?

Algo como:

{{ django_context_varable }} #works
{{% raw %}}
<script id="restaurants-tpl" type="text/x-handlebars-template">
    <ul>
    {{#restaurants}} #not rendered by django, plain text
    <li>{{name}}</li>
    {{/restaurants}}
    </ul>
</script>
{{% endraw %}}

Editar

Probablemente encontré this . Funciona bien.

Actualizar

Django 1.5 soporta etiqueta verbatim forma nativa.

Answer 1

¿Hay una etiqueta en las plantillas de django para dejar de representar un bloque con llaves?

Respuesta ANTIGUA para Django 1.0-1.4: No, aunque podría poner el bloque en un archivo separado e incluirlo sin renderizar o usar un motor de plantillas diferente.

Nueva respuesta : la respuesta anterior fue correcta en agosto de 2011 cuando se hizo la pregunta y se respondió. Comenzando en Django 1.5 (publicado en febrero de 2013, aunque versiones alfa / beta a fines de 2012), introdujeron {% verbatim %} y {% endverbatim %} lo que evitará que el motor de plantillas de django procese el contenido del bloque.

Por lo tanto, para la pregunta que se hace, lo siguiente funcionará en django 1.5+ fuera de la caja:

{{ django_context_varable }} #works
{% verbatim %}
<script id="restaurants-tpl" type="text/x-handlebars-template">
    <ul>
    {{#restaurants}} #not rendered by django, plain text
    <li>{{name}}</li>
    {{/restaurants}}
    </ul>
</script>
{% endverbatim %}

La documentación en textual está aquí . Sí, esto fue observado por otros antes, pero como esta es la respuesta aceptada, debería enumerar la solución más fácil.

Answer 2

¡Compila tus manillares primero!

Desde manillares precompilación de documentación :

Además de reducir el tamaño de la descarga, la eliminación de la compilación del lado del cliente acelerará significativamente el tiempo de arranque, ya que la compilación es la parte más costosa de Handlebars.

Puede compilar plantillas en su entorno de compilación utilizando el módulo npm de las barras de control , o integrarlo con una herramienta de construcción como gulp con las barras de control .

Después de compilar, sus plantillas de manillares pueden servir como recursos estáticos y omitir la representación del lado del servidor. Hace que sea más fácil en el almacenamiento en caché también :)

El uso típico se vería así:

<div id="restaurants-tpl">
    Waiting for content...
</div>

<script src="{% static ''js/handlebars.runtime.js'' %}"></script>
<script src="{% static ''js/templates.js'' %}"></script>
<script>
    // Let django render this as a json string
    properties = {{ properties }};

    // Use Handlebars compiled template imported above
    rendered_html = Handlebars.templates["restaurants-tpl"](properties);

    // Set element content 
    document.getElementById("restaurants-tpl").innerHTLM = rendered_html;
</script>

Answer 3

¿Por qué no usar jinja2 en jinja2 lugar? En mi opinión, ambos son elegantes de usar. Aquí hay un excelente artículo al respecto: Uso de Jinja2 con Django

Answer 4

El sistema de plantillas de Django no admite bloques de escape a la vez. Sería fácil evitarlo si no fuera por el hecho de que, cuando se procesan las plantillas, el tokenizador no guarda información exacta sobre cómo se veían los tokens antes de ser tokenizados.

He usado la siguiente solución temporal que es fea, pero (más o menos) funciona. Use diferentes delimitadores de etiquetas en sus plantillas y una etiqueta de plantilla de django que las traduzca a lo que realmente quiere:

@register.tag(name="jstemplate")
def do_jstemplate(parser, token):
    while self.tokens:
        token = self.next_token()
        if token.token_type == TOKEN_BLOCK and token.contents == endtag:
            return
    self.unclosed_block_tag([endtag])
    nodelist = parser.parse( (''endjstemplate'',) )
    parser.delete_first_token()
    s = token.split_contents()
    tmpl_id = Variable( s[1] ) if (len(s) == 2 and s[1]) else ''''
    return JsTemplateNode( nodelist, tmpl_id )

class JsTemplateNode(template.Node):
    def __init__(self, nodelist, tmpl_id=''''):
        self.tmpl_id = tmpl_id
        self.nodelist = nodelist
    def render(self, context):
        content = self.nodelist.render(context)
        return u''<script id="%s" type="text/x-handlebars-template">%s</script>'' % (
                self.tmpl_id.resolve(context),
                re.sub( ur''{/$(.*?)/$}'', u''{{//1}}'', content ), )

Para obtener puntos de bonificación, puede aprovechar las plantillas de Django dentro de sus plantillas ... lo que probablemente cocinará su cerebro tratando de desenredar más adelante:

{% jstemplate "restaurants-tpl" %}
{$#restaurants$}
<div id="<$name$<" class="{$type$}">
    <ul class="info">
        {$#if info/price_range$}<li><em>{{ trans "Price Range" }}:</em> {$info/price_range$}</li>{$/if$}
        {$#if info/awards$}<li><em>{{ trans "Awards" }}:</em> {$info/awards$}{$/if$}
    </ul>
    <div class="options">
        <button>{% trans "Reservation" %}</button>
    </div>
</div>
{$/restaurants$}
{% jstemplate %}

Answer 5

En realidad escribí una plantilla de filtro personalizado que es así:

from django import template
register = template.Library()
def handlebars(value):
    return ''{{%s}}'' % value
register.filter(''handlebars'', handlebars)

y utilízalo en una plantilla como tal:

{{"this.is.a.handlebars.variable"|handlebars}}

Es lo más simple que se me ocurre. Solo tienes que poner el nombre de la variable de tu manillar entre comillas. Lamento no haber tenido esta idea antes de luchar con ssi. Funciona también con palabras clave:

{{"#each items"|handlebars}}

Answer 6

Escribí una aplicación django muy pequeña: django-templatetag-handlebars exactamente para ese propósito.

{% load templatetag_handlebars %}

{% tplhandlebars "tpl-infos" %}
    {{total}} {% trans "result(s)." %}
    <p>{% trans "Min" %}: {{min}}</p>
    <p>{% trans "Max" %}: {{max}}</p>
{% endtplhandlebars %}

Haz tu bloque como de costumbre usando la API Handlebars.js :

var properties = {
    total: 10,
    min: 5,
    max: 4
};

var template = Handlebars.compile($(''#tpl-infos'').html()),
    rendered = template(properties);

Lo escribí el día que @chrisv publicó su paquete, con un enfoque KISS en mente. Se basa principalmente en la esencia de Miguel Araujo: https://gist.github.com/893408 .

Answer 7

Utilizo una etiqueta de plantilla personalizada para otro sistema de plantillas js, aquí: https://gist.github.com/629508

Usar en plantilla:

{% load mytags %}
{% verbatim %}
  {{ This won''t be touched by {% django''s %} template system }}
{% endverbatim %}

Edición: esta etiqueta de plantilla personalizada ya no es necesaria, ya que el lenguaje de la plantilla de Django ahora admite la etiqueta de plantilla {% verbatim%}.

Answer 8

para una integración más profunda entre los manillares y Django (incluida la precompilación sobre la marcha opcional), consulte mi proyecto en https://bitbucket.org/chrisv/django-handlebars/

Básicamente funciona así:

1. crear plantilla de HB bajo

   appdirectory/hbtemplates/myapp/template.html

   (Al igual que la plantilla Django)

2. en tu app usa

   {% handlebars myapp %} 

   Etiqueta de plantilla y plantilla de render como tal:

   Handlebars.templates["myapp.template.html"]({context:"value"});