A question involving variable evaluation

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

On Mar 21, 7:57 am, mike leonard [email protected] wrote:

if the_match then

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

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] }

2008/3/21, mike leonard [email protected]:

On Mar 21, 12:41 pm, Ravil B. [email protected] wrote:

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?

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) }

2008/3/21, mike leonard [email protected]:

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs