Regex for certain string and digit for time - ruby-on-rails

Question

anyone can help me?
I have a string with format: 10 mins - 20 mins OR 1 min - 10 mins OR 10 mins - 1 hour OR 10 mins - 1 hour 30 mins OR 10 mins - 2 hours OR 10 mins - 2 hours 30 mins.
I wanna create a regex for all formats but I can't :disappointed: . Please help me, thanks a lot.
A regex possible with all above formats.

Answer 1

I might split on the dash first, then match out the components in each side using the same regular expression.
E.g.
"1 hour 10 mins - 3 hours".split(/\s+-\s+/, 2).map do |s|
s.scan(
/
\d+ \s+ mins
| \d+ \s+ hour(?=s?)
| \d+ \s+ hour(?=s?)
\s+
\d+ \s+ min(?=s?)
/x
)
end
# => [["1 hour", "10 mins"], ["3 hour"]]
"1 hour 10 mins - 40 mins".split(/\s+-\s+/, 2).map do |s|
s.scan(
/
\d+ \s+ mins
| \d+ \s+ hour(?=s?)
| \d+ \s+ hour(?=s?)
\s+
\d+ \s+ min(?=s?)
/x
)
end
# [["1 hour", "10 mins"], ["40 mins"]]

Answer 2

I've assumed:
every string contains only minutes (not hours) to the left of the minus sign; and
hours, where present, are between 1 and 9.
These assumptions are consistent with the examples given in the question.
One can then use String#match and MatchData#named_captures with the regular expression
rgx = /(?<lmin>(?:[1-9]|[1-5]\d)) mins? \- (?:(?<hr>[1-9]) hours?(?: (?<rminwhr>\g<lmin>) mins?)?|(?<rminwohr>\g<lmin>) mins?)/
to extract the values of interest. Let's try it for the examples given in the question.
["10 mins - 20 mins",
"1 min - 10 mins",
"10 mins - 1 hour",
"10 mins - 1 hour 30 mins",
"10 mins - 2 hours",
"10 mins - 2 hours 30 mins"].each do |str|
m = str.match(rgx)
puts str
puts "str.match(rgx) = #{m.inspect}"
puts "captures = #{m.named_captures}"
puts
end
displays the following.
10 mins - 20 mins
str.match(rgx) = #<MatchData "10 mins - 20 mins" lmin:"20" hr:nil rminwhr:nil rminwohr:"20">
captures = {"lmin"=>"20", "hr"=>nil, "rminwhr"=>nil, "rminwohr"=>"20"}
1 min - 10 mins
str.match(rgx) = #<MatchData "1 min - 10 mins" lmin:"10" hr:nil rminwhr:nil rminwohr:"10">
captures = {"lmin"=>"10", "hr"=>nil, "rminwhr"=>nil, "rminwohr"=>"10"}
10 mins - 1 hour
str.match(rgx) = #<MatchData "10 mins - 1 hour" lmin:"10" hr:"1" rminwhr:nil rminwohr:nil>
captures = {"lmin"=>"10", "hr"=>"1", "rminwhr"=>nil, "rminwohr"=>nil}
10 mins - 1 hour 30 mins
str.match(rgx) = #<MatchData "10 mins - 1 hour 30 mins" lmin:"30" hr:"1" rminwhr:"30" rminwohr:nil>
captures = {"lmin"=>"30", "hr"=>"1", "rminwhr"=>"30", "rminwohr"=>nil}
10 mins - 2 hours
str.match(rgx) = #<MatchData "10 mins - 2 hours" lmin:"10" hr:"2" rminwhr:nil rminwohr:nil>
captures = {"lmin"=>"10", "hr"=>"2", "rminwhr"=>nil, "rminwohr"=>nil}
10 mins - 2 hours 30 mins
str.match(rgx) = #<MatchData "10 mins - 2 hours 30 mins" lmin:"30" hr:"2" rminwhr:"30" rminwohr:nil>
captures = {"lmin"=>"30", "hr"=>"2", "rminwhr"=>"30", "rminwohr"=>nil}
lmin reads "minutes to left of minus sign"; rminwhr (rminwohr) reads "minutes to right of minus sign with (without) hours".
One can see a demonstration of the regular expression here. Hover the cursor over the regular expression to see an explanation of the function of each part of the expression. These results are shown for the PCRE regex engine but they are the same for Ruby's regex engine (Oniguruma).
We can write the regular expression in free-spacing mode to make it self-documenting.
/
(?<lmin> # begin capture group 'lmin'
(?: # begin non-capture group
[1-9] # match a digit other than zero
| # or
[1-5]\d # match a digit between 1 and 5, followed by a digit
) # end non-capture group
) # end capture group 'lmin'
[ ]mins? # match a space followed by 'min', 's' optional
[ ]\-[ ] # match ' - '
(?: # begin non-capture group
(?<hr> # begin capture group 'hr'
[1-9] # match a digit other than zero
) # end capture group 'hr'
[ ]hours? # match a space followed by 'hour', 's' optional
(?: # begin a non-capture group
[ ] # match a space
(?<rminwhr> # begin capture group 'rminwhr'
\g<lmin> # invoke subexpression 'lmin'
) # end capture group 'rminwhr'
[ ]mins? # match a space followed by 'min', 's' optional
) # end non-capture group
? # make the preceding non-capture group optional
| # or
(?<rminwohr> # begin capture group 'rminwohr'
\g<lmin> # invoke subexpression 'lmin'
) # end capture group 'rminwohr'
[ ]mins? # match a space followed by 'min', 's' optional
) # end non-capture group
/x # invoke free-spacing regex definition mode
g<lmin> causes the code used to create named capture group named lmin to be reused at that location. This is called a "subexpression" or "subrouting". For an explanation search for "Subexpression" in Regexp. The use of subexpressions reduces the size of the expression, makes it easier to read and reduces the chances of errors, particularly if the expression is modified in future.
Notice that in free-spacing mode spaces that are intended to part of the expression must be protected in some way to prevent them from being stripped out before the expression is parsed. I've chosen to put each one in a character class, but there are other ways of doing that (for one, escaping the space character).