Existe-t-il un bug dans Ruby dans les affirmations (1.9 / 2.0)?

Question

Pourquoi ne pas les regex (?<=fo).* correspondent foo (alors qu' (?<=f).* t)?

"foo" =~ /(?<=f).*/m          => 1
"foo" =~ /(?<=fo).*/m         => nil

Cela ne semble se produire avec singleline ce mode est activé (point correspond saut de ligne); sans elle, tout est OK:

"foo" =~ /(?<=f).*/           => 1
"foo" =~ /(?<=fo).*/          => 2

Testé sur Ruby 1.9.3 et 2.0.0.

Voir sur Rubular

EDIT: Quelques observations plus:

L'ajout d'un bout de la ligne d'ancrage ne change rien:

"foo" =~ /(?<=fo).*$/m        => nil

Mais avec un paresseux quantificateur, il "fonctionne":

"foo" =~ /(?<=fo).*?$/m       => 2

EDIT: Et quelques observations:

.+ fonctionne comme son équivalent {1,}, mais seulement en Ruby 1.9 (il me semble que c'est la seule différence de comportement entre les deux dans ce scénario):

"foo" =~ /(?<=fo).+/m         => 2
"foo" =~ /(?<=fo).{1,}/       => 2

En Ruby 2.0:

"foo" =~ /(?<=fo).+/m         => nil
"foo" =~ /(?<=fo).{1,}/m      => nil

.{0,} est en panne (dans les deux 1.9 et 2.0):

"foo" =~ /(?<=fo).{0,}/m      => nil

Mais {n,m} fonctionne:

"foo" =~ /(?<=fo).{0,1}/m     => 2
"foo" =~ /(?<=fo).{0,2}/m     => 2
"foo" =~ /(?<=fo).{0,999}/m   => 2
"foo" =~ /(?<=fo).{1,999}/m   => 2

Answer 1

Cela a été officiellement classé comme un bogue et corrigé par la suite , ainsi qu'un autre problème concernant les ancres \Z dans les chaînes multilignes.