Plantilla de HAML parcial en Ruby sin rieles

Question

Realmente no necesito la sobrecarga de Rails para mi proyecto muy pequeño, así que estoy tratando de lograr esto simplemente usando Ruby y HAML.

Quiero incluir otro archivo HAML dentro de mi plantilla HAML. Pero no he encontrado una manera buena o realmente utilizable de hacer esto.

Por ejemplo, tengo estos dos archivos: HAML

documents.haml

%html 
%body 
    = include(menu.haml) body 
    %article … 

menu.haml

%ul 
%li 
    %a whatever … 

Incluir obviamente no es el camino a seguir aquí. Pero hace un buen trabajo al describir lo que intento lograr en este ejemplo.

Answer 1

He hecho esto antes, solo para un productor de plantillas rápido y sucio. La forma más fácil es simplemente hacer que el HAML dentro del objeto padre:

%p some haml that's interesting 
= Haml::Engine.new('%p this is a test').render 
%p some more template 

usted más que probable que quieren construir algunos métodos para hacer esto más fácil - un par de métodos de ayuda. Tal vez usted escriba uno llamado archivo_de_ejecución que toma un nombre de archivo como argumento. Ese método podría ser algo como:

def render_file(filename) 
    contents = File.read(filename) 
    Haml::Engine.new(contents).render 
end 

A continuación, la plantilla se vería más como:

%p some template 
= render_file('some_filename.haml') 
%p more template 

Nota, es probable que necesite para pasar a la auto Haml originales :: motor de render para que se sabe cómo encontrar su método render_file.

Answer 2

Recomiendo totalmente la gema Tilt para estas cosas. Proporciona una interfaz estándar para representar muchos lenguajes de plantilla diferentes con la misma API, le permite establecer ámbitos personalizados y locales, le permite usar rendimiento y es robusto y rápido. Sinatra lo está usando para plantillas.

Ejemplo:

require 'haml' 
require 'tilt' 

template = Tilt.new('path/to/file.haml') 
# => #<Tilt::HAMLTemplate @file="path/to/file.haml" ...> 
layout = Tilt.new('path/to/layout.haml') 

output = layout.render { template.render } 

Esto le permite yield dentro del diseño para obtener la plantilla prestado, al igual que los carriles. En cuanto a los parciales, David ya describió una manera simple y agradable de ir.

Pero en realidad, si lo que está escribiendo va a ser servido a través de HTTP, le sugiero que eche un vistazo a Sinatra, que ya proporciona plantillas, y tiene el enrutamiento de solicitud más simple que pueda imaginar.

Answer 3

def render_file(filename) 
    contents = File.read('views/'+filename) 
    Haml::Engine.new(contents).render 
end 

Answer 4

He tenido un gran éxito simplemente siguiendo las instrucciones publicadas por David Richards de una manera concatenada, sin variables, como esto:

= Haml::Engine.new(File.read('/Volumes/Project/file_to_include.haml')).render

Obviamente hay una forma más elegante. Pero para alguien que solo quiere incluir uno o dos archivos, esto debería funcionar bien. Es un inconveniente que todos los archivos base que usan estos incluyen deben ser recompilados después de algunos cambios en este último. Tal vez valga la pena usar php include si el entorno lo permite.

Answer 5

(La adición de esta respuesta semi-redundante para mostrar cómo se podría incorporar las técnicas de otras respuestas.)

incluir algo como esto en su código de configuración de mono-parchear la biblioteca Haml.

module Haml::Helpers 
    def render_haml(filename) 
    contents = File.read(Rails.root.join("app", "assets", "templates", filename)) 
    Haml::Engine.new(contents).render 
    end 
end 

Luego, en su Haml el archivo

.foo 
= render_haml('partial.haml') 
.bar 

Obviamente, esto es un ejemplo Rieles-ish (porque quería utilizar HAML en mi ducto activo en lugar de como visitas) ... Usted va a querer reemplace Rails.root.join(...) para encontrar filename en el directorio de plantillas o parciales de su proyecto.