Mehrere mehrzeilige HAML-Blöcke

Question

Mit dem (absichtlich) seltsamen Multi-Line-Format für HAML möchte ich die folgenden Zeilen in meiner Vorlage haben:

= 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' |

Sie können jedoch nicht gegeneinander antreten oder werden als ein einzelner Multi-Line-Block gelesen.

-# 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' |

Und die Trennung von einer Linienpause interessanterweise nicht besser:

-# 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' |

Die einzige Arbeitslösung, die ich gefunden habe, besteht darin, eine leere Zeile von Ruby -Code dazwischen auszuführen. Was wirklich hässlich aussieht.

= 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' |

Gibt es etwas Besseres?

Answer 1

Dies ist eine Funktion, kein Fehler. Haml -Multilinblöcke sind absichtlich unhandlich - einschließlich schwer zu folgen nacheinander -, denn fast immer ist es besser, diesen Rubincode in einen Helfer zu bringen. Selbst wenn der Helfer nur einmal aufgerufen wird, wird Ihre Vorlage viel einfacher zu lesen. Zum Beispiel:

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

Dann in Ihrem Haml einfach tun

= blatz_link
= blootz_link

Das wird viel lesbarer und leichter zu verstehen sein.

---

Wenn Sie mit einem anderen einem Multiline -Block unbedingt folgen müssen, fügen Sie einfach einen Kommentar dazwischen hinzu:

= 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

Ich habe die gleichen Probleme und Problemumgehungen wie erwähnt, und das seltsame (und ja, es ist seltsam) von Haml in Bezug auf Multi-Line-Blöcke hat mich einige Male gebissen. Ich weiß, dass es beabsichtigt ist und dass es wahrscheinlich beabsichtigt war, den Benutzer zu zwingen, seinen Code leichter zu lesen. Es ist jedoch eine bekannte Tatsache, dass jeder Entwickler seine eigenen Vorlieben hat, wenn es darum geht, Code zu strukturieren. Haml ist die einzige Sprache, die ich kenne (C, C ++, Ruby, Python, HTML usw.), die versucht, solche Einschränkungen aufzuerlegen.

Wenn Sie den seltsamen Multi-Line-Umgang mit einer Funktion anstelle eines Fehlers aufrufen, zeigt dies nur ein fehlerhaftes Sprachdesign an. Am Ende wird es in den Augen des Benutzers immer ein Fehler sein. Multi -Line -Support ist eine grundlegende Funktion jeder Hauptstream -Sprache, und das Fehlen dieser Funktion ist einfach nur Annoing - genau wie die M $ paperclip, die meiner Meinung nach auch ein Versuch war, den Benutzer zu leiten.

Davon abgesehen ist Haml eine fantastisch kompakte und nützliche Sprache für das Schreiben von HTML. Diejenigen von uns, die (in einigen Fällen) Multi -Line -Blöcke bevorzugen würden, würden es einfach lieben, zumindest eine Art Konfigurationsoption zu bieten, um eine anständige Unterstützung für den Multi -Line -Block zu aktivieren/zu deaktivieren - unabhängig von der persönlichen Definition des Sprachdesigners von "einfach zu lesen Code ".

Bis wir dort ankommen, müssen wir mit dem "-#" Hack ...

Answer 3

Sie könnten einen Block auf Ihrem Helfer verwenden und was auch immer sinnvoll ist.

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

Jetzt auf deinem 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 ist ein Hack (Sort-of), aber Sie könnten immer ein "+" anstelle eines "=" auf Ihrem 2., 3. usw. Linien in der Kette verwenden.

= 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' |