ruby-on-rails - rails - slim html

Bloques multiples líneas HAML

Question

Usando el formato multilínea extraño (intencionalmente) 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, no pueden coincidir entre sí, o se leen como un único bloque multilínea.

-# 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 separarse con un salto de línea, curiosamente, no lo 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 de trabajo que he encontrado es ejecutar una línea en blanco de código Ruby entre. Lo que 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

Es un truco, pero siempre puedes usar un "+" en lugar de un "=" en tus líneas 2, 3, etc. en 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 2

Esto es una característica, no un error. Los bloques multilínea de Haml son intencionadamente difíciles de manejar, incluso difíciles de seguir uno tras otro, porque casi siempre es mejor poner ese código de Ruby en un ayudante. Incluso si solo se llama al ayudante 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

Entonces en tu Haml, solo haz

= blatz_link
= blootz_link

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

Si absolutamente debe seguir un bloque multilínea con otro, solo agregue un comentario entre:

= 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

Me he encontrado con los mismos problemas y soluciones que se han mencionado aquí, y el comportamiento extraño (y sí, ES Raro) de HAML con respecto a los bloques multilínea me ha mordido unas cuantas veces. Sé que es intencional y que probablemente fue para forzar 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 estructurar código. HAML es el único lenguaje que conozco (c, c ++, ruby, python, HTML, etc.) que intenta imponer tales restricciones.

Llamar a la extraña multilínea manejando una característica en lugar de un error, solo 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 transmisión principal, y la falta de esta característica es simplemente una anulación, al igual que el clip M $, que creo que también fue un intento de guiar al usuario.

Dicho esto, HAML es un lenguaje increíblemente compacto y útil para escribir HTML. Aquellos de nosotros que (en algunos casos) preferimos los 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 del bloque multilínea, independientemente de la definición personal del diseñador de idiomas de "código fácil de leer" ".

Hasta que lleguemos allí, supongo que tendremos que solucionar el lenguaje usando el hack "- #" ...

Answer 4

Podrías usar un bloque en tu ayudante, dando 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 tu 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''