Bug when rerouting String#gsub with a block using $1?

[Florian Gross]

Moin!

This code:

class String
alias ld_gsub :gsub
def gsub(*args, &block)
old_gsub(*args, &block)
end
end

"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"

produces this output for me:

nilnil

(I'm using ruby 1.8.0 (2003-08-04) [i386-mswin32] and I'm told that it
does the same in the 1.8.0 final, 1.7.3 and 1.6.8 on Linux.)

Is this behaviour by design or is this a bug? If it's not a bug: Why
is $1 changed to nil in this case?

(This behaviour is causing an annoying bug in my new Ruby
implementation of Perl 6's Junctions and thus effectively replacing
irb's prompt with "()::>")

Thanks for any answers and effort to clarify this issue!

Regards,
Florian Gross

 

[Mauricio Fernández]

Moin!

This code:

class String
alias ld_gsub :gsub
def gsub(*args, &block)
old_gsub(*args, &block)
end
end

"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"

produces this output for me:

nilnil

(I'm using ruby 1.8.0 (2003-08-04) [i386-mswin32] and I'm told that it
does the same in the 1.8.0 final, 1.7.3 and 1.6.8 on Linux.)

Is this behaviour by design or is this a bug? If it's not a bug: Why
is $1 changed to nil in this case?

It seems it is by design:

batsman@tux-chan:/tmp$ expand -t2 a.rb
def foo
puts "Match: #{$1.inspect}"
end

"abcd" =~ /(b)/
foo
puts "Match: #{$1.inspect}"

batsman@tux-chan:/tmp$ ruby a.rb
Match: nil
Match: "b"

So $1 is method-scoped.

Now, is there any way to propagate $1??
We need it if gsub and friends are to be wrapped transparently.

--
_ _
| |__ __ _| |_ ___ _ __ ___ __ _ _ __
| '_ \ / _` | __/ __| '_ ` _ \ / _` | '_ \
| |_) | (_| | |_\__ \ | | | | | (_| | | | |
|_.__/ \__,_|\__|___/_| |_| |_|\__,_|_| |_|
Running Debian GNU/Linux Sid (unstable)
batsman dot geo at yahoo dot com

One tree to rule them all,
One tree to find them,
One tree to bring them all,
and to itself bind them.
-- Gavin Koch <[email protected]>

 

[Mauricio Fernández]

|Now, is there any way to propagate $1??
|We need it if gsub and friends are to be wrapped transparently.

Explicitly? You can pass the match data and assign it to $~.

But this doesn't solve the problem, does it?

I don't see how $~ would help in

class String
alias ld_gsub :gsub
def gsub(*args, &block)
old_gsub(*args, &block)
end
end

"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"

Is this just impossible to do in Ruby?

At any rate the behavior of the block is quite strange w.r.t. the binding
of $1. It is very different from that of other variables/globals in the
closure: $1 references the $1 in gsub, instead of the one in old_gsub
or the outer one.

However

batsman@tux-chan:/tmp$ expand -t2 b.rb

def foo
"foo" =~ /(foo)/
yield
end

def bar
"bar" =~ /(bar)/
foo { puts "foo: " + $1.inspect }
yield
end

bar {puts "bar: " + $1.inspect}

puts "1 world".gsub(/(1)/) { $1 + " is one" }

batsman@tux-chan:/tmp$ ruby b.rb
foo: "bar"
bar: nil
1 is one world

So gsub is indeed one special case in that $1 is bound to the "inner $1"
instead of the outer. And there's AFAIK no way to wrap gsub without
breaking it because of that.


--
_ _
| |__ __ _| |_ ___ _ __ ___ __ _ _ __
| '_ \ / _` | __/ __| '_ ` _ \ / _` | '_ \
| |_) | (_| | |_\__ \ | | | | | (_| | | | |
|_.__/ \__,_|\__|___/_| |_| |_|\__,_|_| |_|
Running Debian GNU/Linux Sid (unstable)
batsman dot geo at yahoo dot com

Turn right here. No! NO! The OTHER right!

 

[Yukihiro Matsumoto]

Hi,

In message "Re: Bug when rerouting String#gsub with a block using $1?"

| "hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"
|
|Is this just impossible to do in Ruby?

In pure Ruby, yes.

Ah, wait. If you don't need thread safety, you can do it as:


"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"
class String
alias ld_gsub :gsub
def gsub(*args, &block)
if block
old_gsub(*args) {
$match = $~
eval("$~ = $match", block) # the trick here.
yield $&
}
else
old_gsub(*args, &block)
end
end
end
"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"

matz.

 

[Mauricio Fernández]

Hi,

In message "Re: Bug when rerouting String#gsub with a block using $1?"

| "hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"
|
|Is this just impossible to do in Ruby?

In pure Ruby, yes.

ouch. We'll then need C to make real Junctions then (not so bad since
we'd do it anyway for speed).

Ah, wait. If you don't need thread safety, you can do it as:

Thank you for your quick responses.

--
_ _
| |__ __ _| |_ ___ _ __ ___ __ _ _ __
| '_ \ / _` | __/ __| '_ ` _ \ / _` | '_ \
| |_) | (_| | |_\__ \ | | | | | (_| | | | |
|_.__/ \__,_|\__|___/_| |_| |_|\__,_|_| |_|
Running Debian GNU/Linux Sid (unstable)
batsman dot geo at yahoo dot com

Steal my cash, car and TV - but leave the computer!
-- Soenke Lange <[email protected]>

 

[Dan Doel]

What about:

p "hello world".gsub(/(\w+)/) { puts $1; $1 }
puts

class String
alias ld_gsub :gsub
def gsub(*args, &block)
if block
pattern = args[0]
old_gsub(pattern) { |match|
eval "#{pattern.inspect} =~ \"#{match}\"", block
yield match
}
else
old_gsub(*args, &block)
end
end
end

p "hello world".gsub(/(\w+)/) { puts $1; $1 }

Or does this miss something that gsub does?

- Dan

 

[nobu.nokada]

Hi,

At Mon, 18 Aug 2003 16:47:47 +0900,

Ah, wait. If you don't need thread safety, you can do it as:

You forget the trick that you'd written ago.

"hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"
class String
alias ld_gsub :gsub
def gsub(*args, &block)
if block
old_gsub(*args) {

eval("proc{|m|$~ = m}", block).call($~)

 

[Florian Gross]

Hi,
Moin!

In message "Re: Bug when rerouting String#gsub with a block using $1?"

|Is this just impossible to do in Ruby?

In pure Ruby, yes.

Ah, wait. If you don't need thread safety, you can do it as:

[code snippet snipped]

That's a nice hack, thank you! And I think Nobu Nakada's change even
makes it thread-safe, but are you sure that the incosistent behavior
of $1 in blocks passed to gsub is needed? IMHO this is a confusing
trap and thus a source of unnecessary debugging sessions for users.

That aside: Are there other methods like sub, sub!, gsub and gsub!
which have this special behavior?

matz.

Regards and thank you for designing a wonderful language,
Florian Gross

 

[Yukihiro Matsumoto]

Hi,

In message "Re: Bug when rerouting String#gsub with a block using $1?"

|That's a nice hack, thank you! And I think Nobu Nakada's change even
|makes it thread-safe, but are you sure that the incosistent behavior
|of $1 in blocks passed to gsub is needed? IMHO this is a confusing
|trap and thus a source of unnecessary debugging sessions for users.

Then don't use ugly dollar variables. But perhaps gsub should have
passed the match data to the block for convenience.

|That aside: Are there other methods like sub, sub!, gsub and gsub!
|which have this special behavior?

"gets" modifies $_ in local scope. $_ and $~ (and $1 etc) are treated
specially.

matz.