Porque el regex no(?<=fo).* partidofoo (mientras(?<=f).* hace)?

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

Esto solo parece ocurrir con el modo de línea única activado (el punto coincide con la nueva línea); Sin él, todo está bien.

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

Probado en Ruby 1.9.3 y 2.0.0.

Véalo en Rubular

EDITAR: Algunas observaciones más:

Agregar un ancla de fin de línea no cambia nada:

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

Pero junto con un cuantificador perezoso, "funciona":

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

EDITAR: Y algunas observaciones más:

.+ Funciona igual que su equivalente.{1,}, pero solo en ruby ​​1.9 (Parece que esa es la única diferencia de comportamiento entre los dos en este escenario):

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

En Ruby 2.0:

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

.{0,} es reventado (tanto en 1.9 como en 2.0):

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

Pero{n,m} trabaja en ambos:

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