Question

Given a regular expression:

/say (hullo|goodbye) to my lovely (.*)/

and a string:

"my $2 is happy that you said $1"

What is the best way to obtain a regular expression from the string that contains the capture groups in the regular expression? That is:

/my (.*) is happy that you said (hullo|goodbye)/

Clearly I could use regular expressions on a string representation of the original regular expression, but this would probably present difficulties with nested capture groups.

I’m using Ruby. My simple implementation so far goes along the lines of:

class Regexp
  def capture_groups
    self.to_s[1..-2].scan(/\(.*?\)/)
  end
end

regexp.capture_groups.each_with_index do |capture, idx|
  string.gsub!("$#{idx+1}", capture)
end
/^#{string}$/

Answer 1

So once I realised that what I actually need is a regular expression parser, things started falling into place. I discovered this project:

• https://github.com/dche/randall

which can generate strings that match a regular expression. It defines a regular expression grammar using http://treetop.rubyforge.org/. Unfortunately the grammar it defines is incomplete, though useful for many cases.

I also stumbled past https://github.com/mjijackson/citrus, which does a similar job to Treetop.

I then found this mind blowing gem:

• https://github.com/ammar/regexp_parser

which defines a full regexp grammar and parses a regular expression into a walkable tree. I was then able to walk the tree and pick out the parts of the tree I wanted (the capture groups).

Unfortunately there was a minor bug, fixed in my fork: https://github.com/LaunchThing/regexp_parser.

Here’s my patch to Regexp, that uses the fixed gem:

class Regexp
  def parse
    Regexp::Parser.parse(self.to_s, 'ruby/1.9')
  end

  def walk(e = self.parse, depth = 0, &block)
    block.call(e, depth)
    unless e.expressions.empty?
      e.each do |s| 
        walk(s, depth+1, &block) 
      end
    end
  end

  def capture_groups
    capture_groups = []
    walk do |e, depth|
      capture_groups << e.to_s if Regexp::Expression::Group::Capture === e
    end
    capture_groups
  end
end

I can then use this in my application to make replacements in my string – the final goal – along these lines:

from = /^\/search\/(.*)$/
to = '/buy/$1'

to_as_regexp = to.dup

# I should probably make this gsub tighter
from.capture_groups.each_with_index do |capture, idx|
  to_as_regexp.gsub!("$#{idx+1}", capture)
end
to_as_regexp = /^#{to_as_regexp}$/

# to_as_regexp = /^\/buy\/(.*)$/

I hope this helps someone else out.