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, no pueden ejecutar una contra otra, o se lee como un bloque de múltiples de una sola lí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 de separación 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 de trabajo que he encontrado es para ejecutar una línea en blanco de código Ruby medio. 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

Esta es una característica, no un error. bloques de varias líneas Haml son intencionalmente difícil de manejar - incluyendo difícil de seguir uno tras otro - porque casi todo el tiempo que es mejor poner ese código Ruby en un ayudante. Incluso si el ayudante sólo se le llama una vez, que hará que su plantilla 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

A continuación, 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

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 multilínea me ha mordido unas cuantas veces. Yo sé que es intencional y que probablemente era la intención de 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 trata de imponer las restricciones.

Al llamar al manejo de una función en lugar de un error de varias líneas raro, simplemente indica un lenguaje de diseño defectuoso. Al final siempre será un error de los ojos del usuario. varias líneas de apoyo es una característica básica de cualquier idioma principal de la corriente y la falta de esta característica es annoing simplemente -. al igual que el M $ clip, que creo que era también un intento de guiar al usuario

Una vez dicho esto, HAML es un lenguaje increíblemente compacto y útil para escribir HTML. Aquellos de nosotros que (en algunos casos) prefieren bloques multilínea acaba de amar al menos ser ofrecido algún tipo de opción de configuración para activar / desactivar el soporte de bloque multi línea decente - independientemente de la definición personal del diseñador del lenguaje de "fácil de leer el código ".

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

Answer 3

Se puede usar un bloque a su ayudante, produciendo 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

Es un hack (tipo de), pero se puede utilizar siempre un "+" en lugar de un "=" en su segunda, tercera, etc. líneas 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' |