Più blocchi Haml multilinea

Question

Uso della (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 eseguire uno contro l'altro, oppure sono letti in un unico blocco multi-linea.

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

La soluzione di lavoro unico che ho trovato è quello di eseguire una riga vuota di codice Ruby mezzo. Il 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. blocchi multilinea Haml sono volutamente poco maneggevole - tra cui difficile da seguire uno dopo l'altro - perché quasi tutto il tempo è meglio mettere quel codice Ruby in un aiutante. Anche se l'aiuto viene chiamato una sola volta, che renderà il vostro 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

ho incontrato gli stessi problemi e le soluzioni temporanee, come sono stati menzionati qui, e la strana (e sì, è strano) il comportamento di HAML per quanto riguarda i blocchi multilinea mi ha morso un bel paio di volte. So che è intenzionale e che probabilmente era destinato a forzare l'utente a fare il suo codice più leggibile. Tuttavia, è un fatto ben noto che ogni sviluppatore ha le sue preferenze quando si tratta di strutturazione del codice. HAML è l'unica lingua che conosco (C, C ++, Ruby, Python, HTML, ecc), che cerca di imporre le restrizioni.

Chiamando la strana gestione di una caratteristica piuttosto che un insetto multi-linea, solo indica un design lingua sbagliata. Alla fine sarà sempre un problema agli occhi degli utenti. Supporto multi-linea è una caratteristica fondamentale di qualsiasi linguaggio di flusso principale e la mancanza di questa caratteristica è annoing semplicemente -. proprio come il M $ graffetta, che credo sia stato anche un tentativo di guidare l'utente

Detto questo, HAML è un linguaggio straordinariamente compatto e utile per la scrittura di codice HTML. Quelli di noi che (in alcuni casi) preferiscono blocchi multilinea sarebbe solo l'amore per almeno essere offerto un qualche tipo di opzione di configurazione per abilitare / disabilitare il supporto blocco multilinea decente - a prescindere dalla definizione personale del designer linguaggio del "codice di facile lettura ".

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

Answer 3

È possibile utilizzare un blocco sul vostro aiutante, cedendo tutto ciò ha un 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

E 'un hack (sorta-di), ma si può sempre usare un "+" al posto di un "=" sul 2 °, 3 °, ecc linee 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' |