Handlebars.js dans les modèles Django

J'ai besoin d'un javascript système de template et je pense que handlebars.js fait un excellent travail dans ce cas.
Je vais avoir la syntaxe des conflits avec un guidon de modèles à l'intérieur d'un django modèle parce que django essaye de rendre guidon variables.

Est-il une balise dans django modèles d'arrêter le rendu d'un bloc avec des accolades?

Quelque chose comme:

{{ 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 %}}

Modifier

Probable que j'ai trouvé cette. Il fonctionne très bien.

Mise à jour

Django 1.5 supporte verbatim balise en mode natif.

+1 pour la mise à jour sur le compte de la balise
J'avais précompiler le guidon modèle et l'utiliser comme une ressource statique: stackoverflow.com/a/42636375/4326531

InformationsquelleAutor tsiokos | 2011-08-29

20

Est-il une balise dans django modèles d'arrêter le rendu d'un bloc avec des accolades?

VIEILLE Réponse pour Django 1.0-1.4: ~~Non, si vous pourriez si vous pouviez mettre le bloc dans un fichier séparé et de les inclure sans rendre ou d'utiliser un autre moteur de template.~~

Nouvelle Réponse: La réponse ci-dessus est correcte en août 2011, lorsque la question a été posée et répondue. Départ dans Django 1.5 (sorti en Février 2013, bien que l'alpha/beta versions à la fin de 2012), ils ont introduit la {% verbatim %} et {% endverbatim %} qui empêchera le moteur de template de django à partir de traitement du contenu dans le bloc.

Donc, pour la question posée, la suite des travaux dans django 1.5+ de la boîte:
```
{{ 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 documentation sur verbatim est ici. Oui, cela a été noté par d'autres plus tôt, mais comme c'est la réponse que je devrais liste la solution la plus simple.
- {% include_raw %} tag personnalisé semble être la meilleure option.
- {% ssi %} fait la même chose (comme {% include_raw %}) et il est déjà dans la norme
- Pour les nouvelles versions de Django, assurez-vous d'utiliser une seule accolade balises comme ceci: `` {% verbatim %} {% endverbatim %} ``
InformationsquelleAutor dr jimbob
30

- Je utiliser un modèle personnalisé pour un autre tag js système de template, ici:
https://gist.github.com/629508

Utiliser dans le modèle:
```
{% load mytags %}
{% verbatim %}
  {{ This won't be touched by {% django's %} template system }}
{% endverbatim %}
```
Edit: Ce personnalisées balise de modèle n'est plus nécessaire, comme Django template language prend désormais en charge l' {% verbatim %} balise de modèle.
- Solution intelligente -- un bloc balise qui tente de reconstituer la structure d'origine à partir de l'analyse de la structure. Je ne suis pas sûr que cela fonctionnera dans tous les cas-par exemple, si il y a des erreurs dans le modèle de django-POV ou si elle a utilisé quelque chose de plus que juste {% et {{ (par exemple, un filtre comme {{ some_var|some_filter:"hello"}}). Mais il peut très bien le travail pour les cas nécessaire.
- Avez-vous essayé le code dans votre gist sur django 1.4.1 ? Je suis tout à fait de la difficulté avec un exemple trivial moi-même et était curieux de savoir si c'était encore une pièce de théâtre en option
- Verbatim a été introduit dans le PIF 1.5.
InformationsquelleAutor rych
3

pour une intégration plus poussée entre le guidon et Django (y compris en option sur la volée de précompilation) découvrez mon projet à
https://bitbucket.org/chrisv/django-handlebars/

Il fonctionne en fait comme ceci:
1. créer HB modèle sous
```
appdirectory/hbtemplates/myapp/template.html
```
  (tout comme Django template)
2. dans votre application, utilisez
```
{% handlebars myapp %} 
```
  balise de modèle et le modèle de rendu comme suit:
```
Handlebars.templates["myapp.template.html"]({context:"value"});
```
InformationsquelleAutor chrisv

J'ai écrit une très petite application django : django-templatetag-guidon exactement à cette fin.

{% load templatetag_handlebars %}

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

Rendre votre bloc comme d'habitude en utilisant Handlebars.js API :

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

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

Je l'ai écrit le jour @chrisv publié son emballage, avec un BAISER approche à l'esprit. Il est principalement basé sur Miguel Araujo est essentiel : https://gist.github.com/893408.

InformationsquelleAutor leplatrem

2

Compiler votre guidon premier!

De guidon précompilation de la documentation:

En plus de réduire la taille de téléchargement, l'élimination de client-côté de la compilation permettra d'accélérer considérablement le temps de démarrage, la compilation est la partie la plus coûteuse du Guidon.

Vous pouvez compiler des modèles dans votre environnement de compilation à l'aide de guidon module npm, ou l'intégrer à un outil de construction comme gulp avec gulp-guidon.

Après la compilation, le guidon de modèles peut être servi comme statique des ressources et de dérivation côté serveur de rendu tout à fait. Facilite la mise en cache trop 🙂

Utilisation typique pourrait ressembler à ceci:

HTML:
```
<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>
```
InformationsquelleAutor Alexander Holmbäck
1

Pourquoi ne pas utiliser jinja2 à la place? OMI, ils sont à la fois élégante à utiliser. Voici un excellent article sur le sujet: À l'aide de Jinja2 avec Django
- J'ai reformulé ma question, c'est pas une question de changer le système de template que django utilise, j'utilise guidon modèles pour la manipulation du dom.
InformationsquelleAutor jpanganiban

Django template système ne peut pas échapper à des blocs à la fois. Il serait facile de contourner était pas pour le fait que lorsque les modèles sont traitées le tokenizer ne conserve pas les informations exactes sur ce que les jetons ressemblait avant ils ont obtenu sous forme de jeton.

J'ai utilisé le travail autour de ce qui est laid, mais (un peu) de travaux. L'utilisation de balise différent des séparateurs dans vos templates et un django balise de modèle qui se traduit par ces retour à ce que vous voulez vraiment:

@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'{{\}}', content ), )

Pour les points de bonus que vous pouvez tirer parti de Django reinhardt, des modèles à l'intérieur de vos modèles ...
qui va probablement faire cuire votre cerveau à essayer de démêler plus tard:

{% 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 %}

InformationsquelleAutor Borgar

1

En fait, j'ai écrit un modèle personnalisé filtre qui va comme ceci:
```
from django import template
register = template.Library()
def handlebars(value):
    return '{{%s}}' % value
register.filter('handlebars', handlebars)
```
et de l'utiliser dans un modèle comme suit:
```
{{"this.is.a.handlebars.variable"|handlebars}}
```
C'est la chose la plus simple que je pouvais penser. Vous avez juste à mettre votre guidon nom de la variable entre guillemets. Je regrette que je n'avais pas eu cette idée avant que j'ai eu du mal avec la ssi. Cela marche aussi avec les mots-clés:
```
{{"#each items"|handlebars}}
```
InformationsquelleAutor Luke Hall

Vous devez vous connecter pour publier un commentaire.