Question

I am trying to parse a pattern with regular expressions in Ruby. The pattern is something like,

<number>? <comma>? <number>? <term>*

where:

• number is one or more digits
• comma is ","
• term is of the form [.*] or [^.*]

And I am trying to capture the numbers, and all the terms. To clarify, here are some examples of valid patterns:

5,50[foo,bar]
5,[foo][^apples]
10,100[baseball][^basketball][^golf]
,55[coke][pepsi][^drpepper][somethingElse]

In the first, I’d like to capture 5, 50, and [foo,bar]
In the second, I’d like to capture 5, [foo] and [^apples] and so on.

The pattern I came up with is:

/(\d+)?,?(\d+)?(\[\^?[^\]]+\])+/

but this only matches the numbers and the last term. If I remove the + at the end, then it only matches the first term.

Answer 1

Easiest solution that I can think of with minimal effort would probably be to just throw on an additional capture group by surrounding the group and the + that are already there, i.e.

/(\d+)?,?(\d+)?((\[\^?[^\]]+\])+)/

Also, you could probably simplify the \d expressions by just doing (\d*) instead of (\d+)?…

EDIT

Here’s the code used to test the above suggestions:

matches = [ "5,50[foo,bar]",
            "5,[foo][^apples]",
            "10,100[baseball][^basketball][^golf]",
            ",55[coke][pepsi][^drpepper][somethingElse]"
          ]

re = Regexp.new('(\d*),?(\d*)((\[\^?[^\]]+\])+)')

matches.each do |match|
  m = re.match(match)

  puts "\nMatching: #{match}"
  puts "--------------------"

  puts "Match 1: #{m[1]}"
  puts "Match 2: #{m[2]}"
  puts "Match 3: #{m[3]}"
end

and the output:

Matching: 5,50[foo,bar]
--------------------
Match 1: 5
Match 2: 50
Match 3: [foo,bar]

Matching: 5,[foo][^apples]
--------------------
Match 1: 5
Match 2: 
Match 3: [foo][^apples]

Matching: 10,100[baseball][^basketball][^golf]
--------------------
Match 1: 10
Match 2: 100
Match 3: [baseball][^basketball][^golf]

Matching: ,55[coke][pepsi][^drpepper][somethingElse]
--------------------
Match 1: 
Match 2: 55
Match 3: [coke][pepsi][^drpepper][somethingElse]

Edit 2

If you’re wanting tokenization, as per J-_-L’s suggestion with the scan method, add in:

m[3].scan(/\[\^?[^\]]+\]/)