multipli multilinea blocchi Haml

Question

Utilizzando la (volutamente) formato strano multi-linea per HAML, mi piacerebbe avere le seguenti righe nel mio modello:

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

Tuttavia, essi non possono correre contro l'un l'altro, o vengono letti come un unico blocco a più righe.

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

e separare con un'interruzione di linea, abbastanza interessante, non fa meglio:

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

L'unica soluzione di lavoro che ho trovato è quello di eseguire una riga vuota di codice Ruby mezzo. Che sembra davvero brutto.

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

C'è qualcosa di meglio?

Answer 1

questa è una caratteristica, non un bug. I blocchi multiline Haml sono intenzionalmente ingombranti, compresi quelli difficili da seguire uno dopo l'altro, perché quasi sempre è meglio mettere quel codice Ruby in un aiuto. Anche se l'helper viene chiamato una sola volta, renderà il tuo modello molto più facile da leggere. Per esempio:

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 

Poi, nel tuo Haml, basta fare

= blatz_link 
= blootz_link 

che sarà molto più leggibile e più facile da capire.

---

Se è assolutamente necessario seguire un blocco multilinea con un altro, è sufficiente aggiungere un commento in mezzo:

= 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

È una modifica (ordinamento), ma è possibile utilizzare sempre un "+" anziché un "=" sulle linee 2, 3, ecc. Della catena.

= 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

È possibile utilizzare un blocco sul proprio helper, restituendo qualsiasi cosa abbia senso.

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 

Ora sul vostro 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

ho incontrato gli stessi problemi e le soluzioni temporanee, come sono stati menzionati qui, e il bizzarro (e sì, è strano) il comportamento di HAML per quanto riguarda i blocchi multi-linea mi ha morso un bel po 'di volte. So che è intenzionale e che probabilmente è stato pensato per costringere l'utente a rendere il suo codice più facile da leggere. Tuttavia, è un fatto ben noto che ogni sviluppatore ha le sue preferenze quando si tratta di strutturare il codice. HAML è l'unica lingua che conosco (c, C++, ruby, python, HTML, ecc.) Che cerca di imporre tali restrizioni.

Chiamare la strana gestione multi-linea di una funzionalità piuttosto che un bug, indica solo un design linguistico imperfetto. Alla fine sarà sempre un bug negli occhi dell'utente. Il supporto multi-linea è una caratteristica base di qualsiasi linguaggio di streaming principale e la mancanza di questa funzionalità è semplicemente fastidiosa, proprio come la graffetta M $, che credo sia stata anche un tentativo di guidare l'utente.

Detto questo, HAML è un linguaggio straordinariamente compatto e utile per scrivere HTML.Quelli di noi che (in alcuni casi) preferiscono i blocchi multi-linea adorerebbero almeno offrire una sorta di opzione di configurazione per abilitare/disabilitare il supporto decente del blocco multi-riga - indipendentemente dalla definizione personale del progettista linguistico di "codice di facile lettura ".

Fino a quando ci arriviamo, credo che dovremo risolvere la lingua mediante il "- #" mod ...