Wiele wielo-liniowe haml bloki

Question

Używanie (celowo) dziwny formatu wielo-liniowy haml, chciałbym mieć następujące linie w moim szablonu:

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

one jednak nie może działać przeciwko siebie nawzajem lub są odczytywane jako jeden blok wielowierszowy.

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

i oddzielania z przerwą linii, co ciekawe, nie ma lepszego:

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

Rozwiązanie działa tylko znalazłem to uruchomienie pusty wiersz kodu Ruby pomiędzy. Co wygląda naprawdę brzydko.

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

Czy jest coś lepszego?

Answer 1

Jest to cecha, a nie bug. Bloki wielowierszowe Haml są celowo nieporęczne - w tym trudne do naśladowania jeden po drugim - ponieważ prawie cały czas lepiej jest umieścić kod Ruby w pomocniku. Nawet jeśli helper jest wywoływany tylko raz, znacznie ułatwi czytanie twojego szablonu. Na przykład:

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 

Następnie w haml, zrób

= blatz_link 
= blootz_link 

który będzie znacznie bardziej czytelne i łatwiejsze do zrozumienia.

---

Jeśli koniecznie musi śledzić jeden blok multilinii z innym, po prostu dodaj komentarz pomiędzy:

= 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

To hack (rodzaj), ale zawsze można użyć "+" zamiast "=" na drugiej, trzeciej itd. Linii w łańcuchu.

= 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

Można użyć bloku na pomocnika, uzyskując wszystko, co ma sens.

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 

Teraz na 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

Napotkałem te same problemy i obejścia, jak zostały tutaj wymienione, a dziwne (i tak, to dziwne) zachowanie HAML w odniesieniu do bloków wieloliniowych ugryzło mnie kilka razy. Wiem, że jest to zamierzone i prawdopodobnie miało zmusić użytkownika do ułatwienia czytania jego kodu. Jednak dobrze wiadomo, że każdy programista ma swoje własne preferencje dotyczące struktury kodu. HAML jest jedynym znanym mi językiem (c, C++, ruby, python, HTML itd.), Który próbuje narzucić takie ograniczenia.

Wywoływanie dziwacznej obsługi wielu wierszy funkcją, a nie błędem, wskazuje tylko wadliwy projekt języka. W końcu zawsze będzie to błąd w oczach użytkownika. Obsługa wielu linii jest podstawową cechą każdego języka głównego strumienia, a brak tej funkcji jest po prostu irytujący - podobnie jak spinacz M $, który moim zdaniem był również próbą poprowadzenia użytkownika.

W ten sposób HAML jest fantastycznie kompaktowym i przydatnym językiem do pisania HTML.Ci z nas, którzy (w niektórych przypadkach) wolą bloki wieloliniowe, chcieliby przynajmniej zaoferować jakąś opcję konfiguracyjną, aby włączyć/wyłączyć przyzwoitą obsługę bloków wielowierszowych - niezależnie od osobistej definicji projektanta języka "łatwego do odczytania kodu" ".

Dopóki tam dostać, chyba będziemy musieli obejść używając języka „- #” hack ...