Qu'est ce que c' &bloc en Ruby? Et comment ça se passait dans une méthode ici?

Blocs sont assez de base, une partie de ruby. Elles sont délimitées par des do |arg0,arg1| ... end ou { |arg0,arg1,arg2| ... }.

Ils vous permettent de spécifier une fonction de rappel pour passer à une méthode.
Ce rappel peut être invoqué deux façons - soit par la capture
en spécifiant un dernier argument, avec le préfixe &, ou par
à l'aide de la yield mot-clé:

irb> def meth_captures(arg, &block)
       block.call( arg, 0 ) + block.call( arg.reverse , 1 )
     end
#=> nil
irb> meth_captures('pony') do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
in callback! word = "pony" num = 0
in callback! word = "ynop" num = 1
#=> "pony0ynop1" 
irb> def meth_yields(arg)
       yield(arg, 0) + yield(arg.upcase, 1)
     end
#=> nil
irb> meth_yields('frog') do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
in callback! word = "frog", num = 0
in callback! word = "FROG", num = 1
#=> "frog0FROG1"

De noter que notre rappel a été le même dans chacun des cas, nous pouvons supprimer
la répétition de sauver notre rappel dans un objet, puis en le passant à chaque
la méthode. Cela peut être fait en utilisant lambda pour capturer le rappel dans un objet,
et puis passés à une méthode en préfixant avec &.

irb> callback = lambda do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
#=> #<Proc:0x0052e3d8@(irb):22>
irb> meth_captures('unicorn', &callback)
in callback! word = "unicorn", num = 0
in callback! word = "nrocinu", num = 1
#=> "unicorn0nrocinu1"
irb> meth_yields('plate', &callback)
in callback! word = "plate", num = 0
in callback! word = "PLATE", num = 1
#=> "plate0PLATE1"

Il est important de comprendre les différentes utilisations de & ici comme préfixe pour le dernier argument d'une fonction

• dans une définition de fonction, elle capte tout passé bloc dans cet objet
• dans un appel de fonction, il élargit le rappel de l'objet dans un bloc

Si vous regardez autour de blocs sont utilisés partout, en particulier dans les itérateurs, comme Array#each.

La &block est un moyen d'envoyer un morceau de code Ruby dans une méthode, puis d'évaluer ce code dans le champ d'application de cette méthode. Dans votre exemple de code ci-dessus, cela signifie un partiel panier sera rendue dans un div. Je pense que le terme fermeture est utilisé dans l'informatique.

Donc dans votre exemple, le &block est:

<%= render(:partial => "cart", :object => @cart) %>

Bonne lecture et une explication de blocs, procs et lamdas peut être trouvé à Robert Sosinski blog.

Ruby met en œuvre des Blocs, des Proc et des lambdas qui sont considérés comme des fermetures d'usines dans la communauté informatique.
Si vous commencez à apprendre Ruby vous serez rapidement et exécuter un code qui ressemble à ceci.

a = ["dog", "cat", "bird"]
a.alter_each! do |n, i|
  "#{i}_#{n}"
end

Donc ce qui se passe ici?

Nous avons commencer avec un tableau de noms d'animaux et d'appeler la alter_each! méthode passage d'un bloc. Dans ce bloc de code, nous pouvons spécifier la façon dont nous voulons modifier chaque élément. Notre exemple de préfixe de chaque nom d'animal avec sa position dans le tableau. Comme le alter_each! méthode parcourt chaque élément, qu'il va exécuter notre bloc en passant la valeur et l'index. Notre bloc rend compte de ces paramètres, les préfixes de l'index pour le nom et retourne le résultat.
Regardons maintenant le alter_each! méthode.

Avis de la méthode n'a pas de spécifier tous les paramètres, c'est parce que le bloc est automatiquement assigné au mot clé yield. le rendement est appelée comme une fonction en passant la valeur et l'index de chaque élément d'un tableau et en remplaçant la valeur d'origine.

class Array
  def alter_each!
    self.each_with_index do |n, i|
      self[i] = yield(n,i)
    end
  end
end

Que faire si vous avez besoin de passer un paramètre à cette méthode?

Vous pouvez modifier la signature de la méthode pour accepter les paramètres et enfin prendre le bloc avec un param commençant par une esperluette. Dans l'exemple ci-dessous notre bloc sera capturé avec le &bloc param laquelle nous allons invoquer l'appel de la méthode. C'est à la place de l'aide de rendement

class Array
  def modify_each!(add_one = true, &block)
    self.each_with_index do |n, i|
      j = (add_one) ? (i + 1) : i
      self[i] = block.call(n,j)
    end
  end
end

Article complet sur ruby blocs