eval certain regex from file to replace chars in string

Question

I'm new to ruby so please excuse my ignorance :)

I just learned about eval and I read about its dark sides.

what I've read so far:

• When is eval in Ruby justified?

• Is 'eval' supposed to be nasty?

• Ruby Eval and the Execution of Ruby Code

so what I have to do is to read a file in which there are some text such as /e/ 3 which will replace each e with a 3 after evaluation.

so here what i did so far:(working but..)

def evaluate_lines
  result="elt"
  IO.foreach("test.txt") do |reg|
    reg=reg.chomp.delete(' ')
    puts reg
    result=result.gsub(eval(reg[0..2]),"#{reg[3..reg.length]}" )
    p result
  end
end

contents of the test.txt file

/e/ 3
/l/ 1
/t/ 7
/$/ !
/$/ !!

this only works because I know the length of the lines in the file.

so assuming my file has the following /a-z/ 3 my program would be not able to do what is expected from it.

Note

I tried using Regexp.new reg and this resulted with the following /\/e\/3/ which isn't very helpful in this case.

simple example to the `Regexp

str="/e/3"
result="elt"
result=result.gsub(Regexp.new str)
p result #outputs: #<Enumerator: "elt":gsub(/\/e\/3/)>

i already tried stripping off the slashes but even though this wont deliver the desired result thus the gsub() takes two parameters, such as this gsub(/e/, "3").

for the usage of the Regexp, I have already read Convert a string to regular expression ruby

Answer 1

Here's a really simple example that uses vi notation like s/.../.../ and s/.../.../g:

def rsub(text, spec)
  _, mode, repl, with, flags = spec.match(%r[\A(.)\/((?:[^/]|\\/)*)/((?:[^/]|\\/)*)/(\w*)\z]).to_a

  case (mode)
  when 's'
    if (flags.include?('g'))
      text.gsub(Regexp.new(repl), with)
    else
      text.sub(Regexp.new(repl), with)
    end
  end
end

Note the matcher looks for non-slash characters ([^/]) or a literal-slash combination (\\/) and splits out the two parts accordingly.

Where you can get results like this:

rsub('sandwich', 's/and/or/')
# => "sorwich"

rsub('and/or', 's/\//,/')
# => "and,or"

rsub('stack overflow', 's/o/O/')
# => "stack Overflow"

rsub('stack overflow', 's/o/O/g')
# => "stack OverflOw"

The principle here is you can use a very simple regular expression to parse out your input regular expression and feed that cleaned up data into Regexp.new. There is absolutely no need for eval here, and if anything that severely limits what you can do.

With a little work you could alter that regular expression to parse what's in your existing file and make it do what you want.

Answer 2

While you can write something to parse that file, it rapidly gets complicated because you have to parse regular expressions. Consider /\/foo\\/.

There are a number of incomplete solutions. You can split on whitespace, but this will fail on /foo bar/.

re, replace = line.split(/\s+/, 2)

You can use a regex. Here's a first stab.

match = "/3/ 4".match(%r{^/(.*)/\s+(.+)})

This fails on escaped /, we need something more complex.

match = '/3\// 4'.match(%r{\A / ((?:[^/]|\\/)*) / \s+ (.+)}x)

I'm going to guess it was not your teacher's intent to have you parsing regexes. For the purposes of the assignment, splitting on whitespace is probably fine. You should clarify with your teacher.

---

This is a poor data format. It is non-standard, difficult to parse, and has limitations on the replacement. Even a tab-delimited file would be better.

There's little reason to use a non-standard format these days. The simplest thing is to use a standard data format for the file. YAML or JSON are the most obvious choices. For such simple data, I'd suggest JSON.

[
  { "re": "e", "replace": "3" },
  { "re": "l", "replace": "1" }
]

Parsing the file is trivial, use the built-in JSON library.

require 'json'
specs = JSON.load("test.json")

And then you can use them as a list of hashes.

specs.each do |spec|
  # No eval necessary.
  re = Regexp.new(spec["re"])

  # `gsub!` replaces in place
  result.gsub!(re, spec["replace"])
end

The data file is extensible. For example, if later you want to add regex options.

[
  { "re": "e", "replace": "3" },
  { "re": "l", "replace": "1", "options": ['IGNORECASE'] }
]

While the teacher may have specified a poor format, pushing back on bad requirements is good practice for being a developer.