Vários multi-linha HAML blocos

Question

Usando o (intencionalmente) estranho multi-formato de linha para HAML, eu gostaria de ter as seguintes linhas no meu modelo:

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

No entanto, eles não podem correr até um contra o outro, ou eles são lidos como um único multi-linha do bloco.

-# 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 separe com uma quebra de linha, curiosamente, não faz melhor:

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

A única solução que eu achei é para executar uma linha em branco do código de Ruby entre.O que parece realmente feio.

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

Existe coisa melhor?

Answer 1

Esta é uma característica, não um bug.Haml blocos de várias linhas são intencionalmente pesado, incluindo difícil seguir um após o outro - porque quase todo o tempo, é melhor colocar esse código Ruby em um auxiliar.Mesmo se o auxiliar é chamado somente uma vez, ele vai fazer o seu modelo muito mais fácil de ler.Por exemplo:

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

Em seguida, no seu Haml, basta fazer

= blatz_link
= blootz_link

que vai ser muito mais legível e fácil de entender.

---

Se você absolutamente deve seguir uma de várias linhas do bloco com o outro, basta adicionar um comentário 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

Eu encontrei os mesmos problemas e soluções alternativas que foram mencionadas aqui, e o estranho (e sim, é estranho) comportamento de Haml em relação aos blocos de várias linhas me mordeu algumas vezes. Sei que é intencional e que provavelmente pretendia forçar o usuário a facilitar a leitura do seu código. No entanto, é um fato bem conhecido que todo desenvolvedor tem suas próprias preferências quando se trata de estruturar o código. Haml é a única linguagem que conheço (C, C ++, Ruby, Python, HTML, etc.) que tenta impor essas restrições.

Chamar o estranho lidar com várias linhas de um recurso em vez de um bug, apenas indica um design de idioma defeituoso. No final, sempre será um bug aos olhos do usuário. O suporte multi -line é um recurso básico de qualquer linguagem de fluxo principal e a falta desse recurso é apenas um anno - assim como o M $ PaperClip, que eu acredito que também foi uma tentativa de orientar o usuário.

Dito isto, Haml é uma linguagem fantástica e compacta para escrever HTML. Aqueles de nós que (em alguns casos) preferem que os blocos de várias linhas adorassem pelo menos receber algum tipo de opção de configuração para ativar/desativar suporte decente de blocos de várias linhas - independentemente da definição pessoal de "código fácil de ler o designer de idiomas ".

Até chegarmos lá, acho que teremos que contornar o idioma usando o hack "-#" ...

Answer 3

Você pode usar um bloco no seu ajudante, produzindo o que faz sentido.

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

Agora em seu 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

É um hack (meio que), mas você sempre pode usar um "+" em vez de um "=" na sua 2ª, 3ª, etc. linhas na corrente.

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