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

On Mon, Aug 18, 2003 at 02:43:00PM +0900, Yukihiro Matsumoto wrote:

> |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 :old_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!

Hi,

In message "Re: Bug when rerouting String#gsub with a block using $1?"
on 03/08/18, Mauricio Fernández <batsman.geo@yahoo.com> writes:

| "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 :old_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.

On Mon, Aug 18, 2003 at 04:47:47PM +0900, Yukihiro Matsumoto wrote:

> Hi,
>
> In message "Re: Bug when rerouting String#gsub with a block using $1?"
> on 03/08/18, Mauricio Fernández <batsman.geo@yahoo.com> writes:
>
> | "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 <soenke@escher.north.de>

What about:

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

class String
alias :old_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

Hi,

At Mon, 18 Aug 2003 16:47:47 +0900,
Yukihiro Matsumoto wrote:

> 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 :old_gsub :gsub
> def gsub(*args, &block)
> if block
> old_gsub(*args) {

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

> yield $&
> }
> else
> old_gsub(*args, &block)
> end
> end
> end
> "hello world".gsub(/(\w+)/) { print $1; $1 }; print "\n"

--
Nobu Nakada

Yukihiro Matsumoto wrote:

> Hi,

Moin!

> In message "Re: Bug when rerouting String#gsub with a block using $1?"
> on 03/08/18, Mauricio Fernández <batsman.geo@yahoo.com> writes:
>
> |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

Hi,

In message "Re: Bug when rerouting String#gsub with a block using $1?"
on 03/08/18, Florian Gross <flgr@ccan.de> writes:

|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.