múltiples multilínea HAML bloques

Question

Usando el formato multi-línea (intencionalmente) extraño para HAML, me gustaría tener las siguientes líneas en mi plantilla:

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

-# and 

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

Sin embargo, ellos no pueden correr contra unos a otros, o se leen como un único bloque de varias líneas.

-# This fails: 
= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 
= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

y separar con un salto de línea, curiosamente, no hace mejor:

-# This fails, too: 
= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

La única solución a trabajar que he encontrado es para ejecutar una línea en blanco de código Ruby medio. Lo cual se ve muy feo.

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 
- 
= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

¿Hay algo mejor?

Answer 1

Esta es una característica, no un error. Los bloques multilínea Haml son intencionalmente difíciles de manejar, incluso difíciles de seguir, porque casi todo el tiempo es mejor poner ese código Ruby en una ayuda. Incluso si el asistente solo se llama una vez, hará que su plantilla sea mucho más fácil de leer. Por ejemplo:

def blatz_link 
    call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', 
    :foo4 => 'bar4', :foo5 => 'bar5' 
end 

def blootz_link 
    call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', 
    :foo4 => 'bar4', :foo5 => 'bar5' 
end 

Luego, en su Haml, acaba de hacer

= blatz_link 
= blootz_link 

que será mucho más fácil de leer y más fácil de entender.

---

Si es absolutamente necesario seguir una cuadra de varias líneas con otra, basta con añadir un comentario en el medio:

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 
-# 
= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

Answer 2

Es un truco (tipo de), pero siempre se puede usar un "+" en lugar de un "=" en las líneas 2ª, 3ª, etc. de la cadena.

= call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 
+ call_to_helper :foo1 => 'bar1', :foo2 => 'bar2', :foo3 => 'bar3', | 
    :foo4 => 'bar4', :foo5 => 'bar5' | 

Answer 3

Puede usar un bloque en su ayudante, cediendo lo que tenga sentido.

module SomeHelper 
    def call_to_helper 
    foo = Foo.new 
    yield foo 
    # build your html here, using the foo object's attributes 
    end 

    class Foo 
    attr_accessor :foo1, :foo2, :foo3, :foo4, :foo5 
    end 

end 

Ahora en su haml:

= call_to_helper do |foo| 
    -foo.foo1 = 'bar1' 
    -foo.foo2 = 'bar2' 
    -foo.foo3 = 'bar3' 
    -foo.foo4 = 'bar4' 
    -foo.foo5 = 'bar5' 

= call_to_helper do |foo| 
    -foo.foo1 = 'bar1' 
    -foo.foo2 = 'bar2' 
    -foo.foo3 = 'bar3' 
    -foo.foo4 = 'bar4' 
    -foo.foo5 = 'bar5' 

Answer 4

me he encontrado con los mismos problemas y soluciones que se han mencionado aquí, y el raro (y sí, ES raro) el comportamiento de HAML con respecto a los bloques de varias líneas me ha mordido bastantes veces. Sé que es intencional y que probablemente fue para obligar al usuario a hacer que su código sea más fácil de leer. Sin embargo, es un hecho bien conocido que cada desarrollador tiene sus propias preferencias cuando se trata de código de estructuración. HAML es el único idioma que conozco (c, C++, ruby, python, HTML, etc.) que intenta imponer tales restricciones.

Llamar al extraño manejo de varias líneas en lugar de un error, simplemente indica un diseño de lenguaje defectuoso. Al final, siempre será un error a los ojos del usuario. El soporte multilínea es una característica básica de cualquier lenguaje de flujo principal y la falta de esta característica es simplemente molesta, al igual que el clip M $, que creo que también fue un intento de guiar al usuario.

Habiendo dicho eso, HAML es un lenguaje increíblemente compacto y útil para escribir HTML.Aquellos de nosotros que (en algunos casos) preferimos bloques multilínea nos encantaría que al menos se nos ofrezca algún tipo de opción de configuración para habilitar/deshabilitar el soporte decente de bloques de varias líneas, independientemente de la definición personal del diseñador de lenguaje de "código fácil de leer" ".

hasta que lleguemos allí, supongo que tendremos que solucionar el idioma con las "- #" truco ...