Plusieurs blocs HAML multi-ligne

Question

Utilisation de la (intentionnellement) étrange format multi-ligne pour HAML, je voudrais avoir les lignes suivantes dans mon modèle:

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

Cependant, ils ne peuvent pas se heurter à un autre, ou ils sont lus comme un seul bloc sur plusieurs lignes.

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

Et séparant par un saut de ligne, il est intéressant de ne pas mieux:

-# 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 seule solution de travail que j'ai trouvé est de lancer une ligne vierge code Ruby entre. Ce qui semble vraiment moche.

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

Y at-il mieux?

Answer 1

Ceci est une fonctionnalité, pas un bug. HAML blocs multilignes sont volontairement difficiles à manier - y compris difficile à suivre un après l'autre - parce que presque tout le temps, il est préférable de mettre ce code Ruby dans une aide. Même si l'aide est appelée une seule fois, il fera de votre modèle beaucoup plus facile à lire. Par exemple:

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

Alors dans votre Haml, il suffit de faire

= blatz_link
= blootz_link

qui sera beaucoup plus lisible et plus facile à comprendre.

---

Si vous devez absolument suivre un bloc multiligne avec un autre, il suffit d'ajouter un commentaire entre:

= 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

Je l'ai rencontré les mêmes problèmes et solutions de contournement comme cela a été mentionné ici, et l'étrange (et oui, il est bizarre) le comportement de HAML en ce qui concerne les blocs multi-lignes m'a mordu quelques reprises. Je sais que c'est intentionnel et qu'il a probablement été conçu pour forcer l'utilisateur à faire son code plus facile à lire. Cependant, il est un fait bien connu que chaque développeur a ses propres préférences en matière de code de structuration. HAML est la seule langue que je connais (c, c ++, Ruby, Python, HTML, etc.) qui tente d'imposer de telles restrictions.

L'appel de la manipulation étrange sur plusieurs lignes une caractéristique plutôt qu'un bug, tout indique une conception du langage défectueux. En fin de compte, il sera toujours un bug dans les yeux de l'utilisateur. Prise en charge multi-ligne est une caractéristique fondamentale de toute langue principale de cours d'eau et l'absence de cette fonctionnalité est tout simplement annoing -. comme le M paperclip $, ce qui je crois était aussi une tentative pour guider l'utilisateur

Cela étant dit, HAML est un langage incroyablement compact et utile pour l'écriture HTML. Ceux d'entre nous qui (dans certains cas) préfèrent des blocs multi-lignes aimerait juste au moins offrir une sorte d'option de configuration pour activer / désactiver le support de bloc multi-ligne décent - quelle que soit la définition personnelle du concepteur du langage de « facile à lire le code ».

Jusqu'à ce que nous obtenons là, je suppose que nous allons devoir travailler dans la langue en utilisant le « - # » hack ...

Answer 3

Vous pouvez utiliser un bloc sur votre aide, ce qui donne tout 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

Maintenant sur votre 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

Il est un hack (tri de), mais vous pouvez toujours utiliser un « + » au lieu d'un « = » sur votre 2ème, 3ème, etc. lignes dans la chaîne.

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