A question involving variable evaluation

[mike leonard]

Hello friends,

I'm working on some code that will iterate through an array of regex
patterns and values, returning a value when the corresponding regex is
matched:

the_string = "foobar"
patterns_and_values = [[/(foo)(.*)/, "bar"], [/(bar)/, "foo"]]
patterns_and_values.each do |p|
the_match = the_string.match(p[0])
if the_match then
return p[1]
end
end

To make this more useful, I'd like to be able to use the subexpression
globals in the value that is returned, like so:

patterns = [[/(foo)(.*)/, $~[0]], [/(bar)/, $~[1]]

However, what is actually returned is the value of $~[0] at the time
that the patterns array was created, which is nil. Is there a good way
to achieve this without resorting to eval? I'd like to keep the syntax
of the patterns_and_values array as simple as possible, since this
will be exposed to users so that they can add to it as necessary.

Thank you kindly in advance (and apologies if the above syntax isn't
quite right - I don't have Ruby installed on this machine).

--Mike Leonard

 

[mike leonard]

Hello friends,

I'm working on some code that will iterate through an array of regex
patterns and values, returning a value when the corresponding regex is
matched:

the_string = "foobar"
patterns_and_values = [[/(foo)(.*)/, "bar"], [/(bar)/, "foo"]]
patterns_and_values.each do |p|
    the_match = the_string.match(p[0])
    if the_match then
        return p[1]
    end
end

To make this more useful, I'd like to be able to use the subexpression
globals in the value that is returned, like so:

patterns = [[/(foo)(.*)/, $~[0]], [/(bar)/, $~[1]]

However, what is actually returned is the value of $~[0] at the time
that the patterns array was created, which is nil. Is there a good way
to achieve this without resorting to eval? I'd like to keep the syntax
of the patterns_and_values array as simple as possible, since this
will be exposed to users so that they can add to it as necessary.

Thank you kindly in advance (and apologies if the above syntax isn't
quite right - I don't have Ruby installed on this machine).

--Mike Leonard

To simplify this somewhat convoluted question:

After I assign the pattern matching globals ($~[0] et al) to a
variable, is there a way to re-evaluate this variable after a match
has occurred, so as to keep it consistent with the actual current
value of $~[0], as opposed to what the value was when the variable was
created?

Many thanks,

Mike Leonard

 

[Ravil Bayramgalin]

just store a needed match position for every pattern and then use it like that:

string = 'foobar'
patterns = [[/(oo)+(.*)/, 2], [/(.*)bar/, 1]]
p patterns.map {|regexp, position| string[regexp, position] }

Hello friends,

I'm working on some code that will iterate through an array of regex
patterns and values, returning a value when the corresponding regex is
matched:

the_string = "foobar"
patterns_and_values = [[/(foo)(.*)/, "bar"], [/(bar)/, "foo"]]
patterns_and_values.each do |p|
the_match = the_string.match(p[0])
if the_match then
return p[1]
end
end

To make this more useful, I'd like to be able to use the subexpression
globals in the value that is returned, like so:

patterns = [[/(foo)(.*)/, $~[0]], [/(bar)/, $~[1]]

However, what is actually returned is the value of $~[0] at the time
that the patterns array was created, which is nil. Is there a good way
to achieve this without resorting to eval? I'd like to keep the syntax
of the patterns_and_values array as simple as possible, since this
will be exposed to users so that they can add to it as necessary.

Thank you kindly in advance (and apologies if the above syntax isn't
quite right - I don't have Ruby installed on this machine).

--Mike Leonard

To simplify this somewhat convoluted question:

After I assign the pattern matching globals ($~[0] et al) to a
variable, is there a way to re-evaluate this variable after a match
has occurred, so as to keep it consistent with the actual current
value of $~[0], as opposed to what the value was when the variable was
created?

Many thanks,


Mike Leonard

 

[mike leonard]

just store a needed match position for every pattern and then use it like that:

string = 'foobar'
patterns = [[/(oo)+(.*)/, 2], [/(.*)bar/, 1]]
p patterns.map {|regexp, position| string[regexp, position] }

Well the idea is that users will be able to create new filters just by
appending items to the array. For example, if you wanted to convert
FOObar to fooBAR, you could do:

patterns << [/(FOO)(bar)/, $~[0].downcase + $~[1].upcase]

How would this work with your suggestion?

 

[Ravil Bayramgalin]

Oh, i see. Then you can use Proc:

string = 'foobar'
patterns = [[/f(.*)(b.r)/, proc {|match| match[2] + match[1].upcase }]]
p patterns.map {|regexp, block| block.call string.match(regexp) }

just store a needed match position for every pattern and then use it like that:

string = 'foobar'
patterns = [[/(oo)+(.*)/, 2], [/(.*)bar/, 1]]
p patterns.map {|regexp, position| string[regexp, position] }

Well the idea is that users will be able to create new filters just by
appending items to the array. For example, if you wanted to convert
FOObar to fooBAR, you could do:

patterns << [/(FOO)(bar)/, $~[0].downcase + $~[1].upcase]

How would this work with your suggestion?