Conditional regex in Ruby

Anatomy of your pattern

(?=.*(USD))(?(1)\d+|[a-zA-Z])
|    |     | |  |   |_______
|    |     | |  |   Else match a single char a-zA-Z
|    |     | |  |   
|    |     | |  |__
|    |     | |  If group 1 exists, match 1+ digits
|    |     | |
|    |     | |__
|    |     | Test for group 1
|    |     |_________________
|    |     If Clause
|    |___
|    Capture group 1
|__________
Positive lookahead

About the pattern you tried

The positive lookahead is not anchored and will be tried on each position. It will continue the match if it returns true, else the match stops and the engine will move to the next position.

Why does the pattern not match?

On the first position the lookahead is true as it can find USD on the right. It tries to match 1+ digits, but the first char is U which it can not match.

USD 100
⎸
First position

From the second position till the end, the lookahead is false because it can not find USD on the right.

USD 100
 ⎸
Second position   

• Eventually, the if clause is only tried once, where it could not match 1+ digits. The else clause is never tried and overall there is no match.

• For the YEN 300 part, the if clause is never tried as the lookahead will never find USD at the right and overall there is no match.

Interesting resources about conditionals can be for example found at rexegg.com and regular-expressions.info

If you want the separate matches, you might use:

\bUSD \K\d+|[A-Z](?=[A-Z]* \d+\b)

Explanation

• \bUSD Match USD and a space
• \K\d+ Forget what is matched using \K and match 1+ digits
• | Or
• [A-Z] Match a char A-Z
• (?=[A-Z]* \d+\b) Assert what is on the right is optional chars A-Z and 1+ digits

regex demo

Or using capturing groups:

\bUSD \K(\d+)|([A-Z])(?=[A-Z]* \d+\b)

Regex demo

The following pattern seems to work:

\b(?:USD (\d+)|(?!USD\b)(\w+) \d+)\b

This works with caveat that it just has a single capture group for the non USD currency symbol. One part of the regex might merit explanation:

(?!USD\b)(\w+)

This uses a negative lookahead to assert that the currency symbol is not USD. If so, then it captures that currency symbol.

I suggest the information desired be extracted as follows.

R = /\b([A-Z]{3}) +(\d+)\b/

def doit(str)
  str.scan(R).each_with_object({}) do |(cc,val),h|
    h[cc] = (cc == 'USD') ? val : cc.split('')
  end
end

doit 'USD 100'
  #=> {"USD"=>"100"} 
doit 'YEN 300'
  #=> {"YEN"=>["Y", "E", "N"]} 
doit 'I had USD 6000 to spend'
  #=> {"USD"=>"6000"} 
doit 'I had YEN 25779 to spend'
  #=> {"YEN"=>["Y", "E", "N"]} 
doit 'I had USD 60 and CDN 80 to spend'
  #=> {"USD"=>"60", "CDN"=>["C", "D", "N"]} 
doit 'USD -100'
  #=> {} 
doit 'YENS 4000'
  #=> {} 

Regex demo

Ruby's regex engine performs the following operations.

\b          : assert a word boundary
([A-Z]{3})  : match 3 uppercase letters in capture group 1
\ +         : match 1+ spaces
(\d+)       : match 3 digits in capture group 2
\b          : assert a word boundary

TLDR;

An excellent working solution can be found in Wiktor's answer and the rest of the posts.

Long answer:

Since I wasn't perfectly satisfied with Wiktor's explanation of why my solution wasn't working, I decided to dig into it a bit more myself and this is my take on it:

Given the string USD 100, the following regex

(?=.*(USD))(?(1)\d+|[a-zA-Z])

simply won't work. The juice of this whole thing is to figure out why. It turns out that using a lookahead (?=.*(USD)) with a capture group, implicitly suggests that the position of USD (if any is found) is followed by some pattern (defined inside the conditional ((?(1)\d+|[a-zA-Z])) which in this case yields nothing since there's nothing before USD.

If we break it down in steps here's an outline of what -I think- is happening:

1. The pointer is set at the very beginning. The lookahead (?=.*(USD)) is parsed and executed.
2. USD is found but since the expression is a lookahead the pointer remains at the beginning of the string and is not consumed.
3. The conditional ((?(1)\d+|[a-zA-Z])) is parsed and executed.
4. Group 1 is set (since USD has been found) however \d+ fails since the pointer searches from the beginning of the string to the beginning of the string which turns out is the furthest point we can search when using a lookahead! After all that's exactly why it's called a lookahead: The searching has to happen across a range which stops just before this one starts.
5. Since no digits nor anything is found before USD, the regex returns no results. And as Wiktor correctly pointed out:

the second alternative pattern will never be tried, because you required USD to be present in the string for a match to occur.

which basically says that since USD is always present in the string, the system would never jump to the "else" statement even if something was eventually found before USD.

As a counter example if the same regex is tested on this string, it will work:

'YEN USD 100'

Hope this helps someone in the future.