Mehrere mehrzeiligen HAML Blöcke

Question

Mit Hilfe der (absichtlich) seltsame mehrzeiligen Format für HAML, würde Ich mag 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' | 

Allerdings können sie nicht laufen gegen oder sie werden als ein einziger mehrzeiliger 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 mit einem Zeilenumbruch trennt, interessanterweise funktioniert 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 funktionierende Lösung, die ich gefunden habe, ist eine Leerzeile von Ruby-Code zwischen auszuführen. Das sieht wirklich hässlich aus.

= 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 Schöneres?

Answer 1

Dies ist ein Feature, kein Bug. Haml-Multiline-Blöcke sind absichtlich unhandlich - darunter auch schwer nacheinander zu folgen -, weil es fast immer besser ist, diesen Ruby-Code in einen Helfer zu stecken. Selbst wenn der Helfer nur einmal aufgerufen wird, wird Ihre Vorlage viel einfacher zu lesen sein. 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, tun nur

= blatz_link 
= blootz_link 

, die viel besser lesbar und leichter zu verstehen sein wird.

---

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

= 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 ist ein Hack (Sortierung), aber Sie könnten immer ein "+" anstelle eines "=" auf Ihrer 2., 3., usw. Zeilen 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' | 

Answer 3

Sie könnten einen Block auf Ihrem Helfer verwenden, was auch immer Sinn ergibt.

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 Ihrem 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

ich die gleichen Probleme und Abhilfen begegnet sind, wie sie hier erwähnt worden ist, und die seltsame (und ja, es ist seltsam) Verhalten von HAML in Bezug auf Multi-Line-Blöcke hat mich ziemlich oft gebissen. Ich weiß, dass es beabsichtigt ist und dass es wahrscheinlich den Benutzer zwingen sollte, seinen Code lesbarer zu machen. Es ist jedoch eine bekannte Tatsache, dass jeder Entwickler seine eigenen Präferenzen hat, wenn es um die Strukturierung von Code geht. HAML ist die einzige Sprache, die ich kenne (c, C++, Ruby, Python, HTML, usw.), die versucht, solche Beschränkungen aufzuerlegen.

Die seltsame Mehrzeilenbehandlung, die eine Funktion statt eines Fehlers behandelt, weist nur auf ein fehlerhaftes Sprachdesign hin. Am Ende wird es immer ein Fehler in den Augen des Benutzers sein. Die Unterstützung mehrerer Zeilen ist ein grundlegendes Merkmal jeder Sprache des Hauptdatenstroms, und das Fehlen dieser Funktion ist einfach nur Annotieren - genau wie die Büroklammer M $, von der ich glaube, dass sie auch ein Versuch war, den Benutzer zu führen.

Das gesagt, HAML ist eine fantastisch kompakte und nützliche Sprache zum Schreiben von HTML.Diejenigen von uns, die (in einigen Fällen) mehrzeilige Blöcke bevorzugen, würden es lieben, zumindest eine Konfigurationsoption anzubieten, um die anständige Mehrzeilenblock-Unterstützung zu aktivieren/deaktivieren - unabhängig von der persönlichen Definition des Sprachentwicklers von "einfach zu lesendem Code" ".

Bis wir dort sind, denke ich, dass wir um die Sprache zu arbeiten haben mit dem „- #“ Hack ...