template mdn loop literal for es6 concatenar backstick javascript python ruby templates mustache

javascript - mdn - ¿Pueden las plantillas de bigote hacer una extensión de plantilla?



template string mdn (8)

Soy nuevo en Moustache.

Muchos lenguajes de plantillas (p. Ej., Django / Jinja ) te permitirán extender una plantilla "parental" como esa ...

base.html

<html><head></head> <body> {% block content %}{% endblock %} </body> </html>

frontpage.html

{% extends "base.html" %} {% block content %}<h1>Foobar!</h1>{% endblock %}

rendido frontpage.html

<html><head></head> <body> <h1>Foobar!</h1> </body> </html>

Soy consciente de los parciales de Moustache (por ejemplo, {{>content}} ), pero esos parecen ser solo incluidos .

¿Existe una extensión de plantilla para Moustache? O, en su defecto, ¿existe al menos algún patrón de diseño que efectivamente se convierta en equivalentes de extensión de plantilla?

En bigote php, la herencia de la plantilla es compatible desde la versión 2.7.0.

https://github.com/bobthecow/mustache.php/wiki/BLOCKS-pragma

Puede averiguar su versión actual desde el archivo Moustache / Engine.php y buscar la línea que contiene:

class Mustache_Engine { const VERSION = ''2.8.0''; ...

En node.js puedes usar express-handlebars o hogan-express para tener diseños de plantillas de bigote inna, pero la forma en que hacen las cosas es diferente, en ninguno de ellos configuras el diseño en la plantilla en sí, los diseños están registrados en tu código de aplicación .

Estoy jugando con esto ahora en Python (nótese que soy el creador de Mako), agregando un contexto dinámico que captura secciones parece estar haciendo lo correcto, aunque necesitaría probar esto mucho más.

Básicamente estamos usando lambdas, donde un prefijo "<" indica "heredar de esta plantilla" (similar a la sintaxis discutida en https://github.com/mustache/spec/issues/38 ) y un prefijo "$" indica " esta es una sección heredada ".

import pystache class NameSpace(object): def __init__(self, renderer, vars_={}): self.renderer = renderer self._content = {} self.vars = vars_ def add_content(self, name, value): self._content[name] = value def __getattr__(self, key): if key in self.vars: # regular symbol in the vars dictionary return self.vars[key] elif key.startswith("<"): # an "inherit from this template" directive name = key[1:] return inheritor(self, name) elif key.startswith("$"): # a "here''s a replaceable section" directive name = key[1:] if name in self._content: # if we have this section collected, return the rendered # version return sub_renderer(self, name) else: # else render it here and collect it return collector(self, name) else: # unknown key. raise AttributeError(key) def sub_renderer(namespace, key): def go(): def render(nested): return namespace._content[key] return render return go def collector(namespace, key): def go(): def render(nested): content = namespace.renderer.render(nested, namespace) namespace.add_content(key, content) return content return render return go def inheritor(namespace, name): def go(): def render(nested): namespace.renderer.render(nested, namespace) return namespace.renderer.render_name(name, namespace) return render return go

Así que aquí hay algunas plantillas. base.mustache:

<html> {{#$header}} default header {{/$header}} {{#$body}} default body {{/$body}} {{#$footer}} default footer, using {{local key}} {{/$footer}} </html>

hello.mustache:

{{#<base}} {{#$header}} new header {{/$header}} {{#$body}} new body, with {{local key}} {{/$body}} {{/<base}}

y luego para jugar con tres niveles de profundidad, subhello.mustache:

{{#<hello}} {{#$footer}} im some new footer {{/$footer}} {{/<hello}}

Renderizar hello.mustache como este:

renderer = pystache.Renderer(search_dirs=["./templates/"]) print renderer.render_name("hello", NameSpace(renderer, {"local key": "some local key"}))

salida:

<html> new header new body, with some local key default footer, using some local key </html>

Renderizado subhello.mustache:

print renderer.render_name("subhello", NameSpace(renderer, {"local key": "some local key"}))

salida:

<html> new header new body, with some local key im some new footer </html>

Acabo de escribir esto en veinte minutos, y solo he usado handlebars.js un poco en el pasado y pystache por primera vez, así que toda la idea de "bigote" todavía no es profunda para mí. Pero esto parece funcionar?

Moustache no hace extensión de plantilla.

Si realmente desea la extensión de la plantilla, puede utilizar un propósito de biblioteca creado con esta funcionalidad para su idioma / marco de elección.

FYI, estoy usando Node.js / Express, así que probablemente termine usando https://github.com/fat/stache

Podría usar variables que contengan HTML. Un "bigote triple" como {{{variable}}} devolverá el código HTML sin capa. No es exactamente lo mismo que las extensiones de plantilla, pero podría representar frontpage-content.html y luego poner su salida en una variable de content que se pasa a base.html .

( Agregué -content al nombre del archivo frontpage.html con la expectativa de que dicho patrón de nomenclatura ayudará a mantener los nombres de archivo manejables).

Recientemente me encontré en el mismo barco, excepto que vengo de un fondo de mako.

Moustache no permite la extensión / herencia de la plantilla, pero hay algunas opciones disponibles que conozco.

  1. Puedes usar parciales:

    {{>header}} Hello {{name}} {{>footer}}

  2. Puede inyectar funciones de preprocesamiento de plantillas en el contexto para cada plantilla que necesite heredar de alguna otra página:

    {{#extendBase}} Hello {{name}} {{/extendBase}}

    Picadillo:

    { "name": "Walden", "extendBase": function() { return function(text) { return "<html><head></head>" + render(text) + "</body></html>" } } }

  3. Anteponga y anexe el HTML deseado a las páginas relevantes de su controlador.

  4. Tener una plantilla de diseño ala:

    {{>header}} {{{body}}} {{>footer}}

    Y renderice el cuerpo en su controlador, pasándolo a la plantilla de diseño como una variable llamada body .

  5. Implemente la herencia de plantilla, bigote previo, en su código que carga plantillas.

Sin embargo, no utilizaría el bigote triple porque no quiero que el código HTML sin relieve aparezca en ninguna parte, es demasiado arriesgado en mi opinión.

Si alguien más tiene una mejor solución para este problema, me encantaría escucharlo también, ya que aún no me he dado el paso en ninguna de estas direcciones.