Regex: захват только подходящей альтернативы в Ruby

Я ломаю голову от этого: Я создаю простой генератор паролей, который использует шаблон, созданный пользователем. Шаблон содержит буквы a-f, которые обозначают 6 групп символов:

Итак, если пользователь введет ababcd, он/она получит что-то вроде abce1! Шаблон Ababababababccd будет генерировать что-то вроде Robuxejiqu23#. Поскольку Ababababababccd кажется трудночитаемым, я хочу дать возможность сократить его повторениями: Abababababccd можно было бы записать как Ab(ab){5}ccd или даже Ab(ab){5}c{2}d (что было бы глупо, но для полноты картины). [ab] вступает в игру, если вы хотите иметь персонажа из группы a или группы b.

Я «построил» подходящее выражение Regex, которое фиксирует повторения в следующих комбинациях:

1. повторение одного символа, например a{3}, превратится в aaa
2. групповое повторение (ab){2}будет abab
3. Повторение группы XOR [ab]{2} становится либо ab, либо aa, либо ba и т. д.
4. комбинации 2 и 3: (a[bc]d){n}

Выражение регулярного выражения, которое я построил до сих пор, находит все вышеперечисленные случаи: /(?:(\[[abcdef]+\])|\(([\[\]abcdef]+)\)|([abcdef]))\{(\d+)\}/i

Мой рабочий код Ruby выглядит так, но хотелось бы найти более элегантное решение:

# class
REPETITION = /(?:(\[[abcdef]+\])|\(([\[\]abcdef]+)\)|([abcdef]))\{(\d+)\}/i
GROUPS = /\[([abcdefxyz]+)\]/i;

# method generate
pattern = params[:pattern]
group = {
  'A' => params[:group_a].upcase,
  'a' => params[:group_a],
  'B' => params[:group_b].upcase,
  'b' => params[:group_b],
  'C' => params[:group_c].upcase,
  'c' => params[:group_c],
  'D' => params[:group_d].upcase,
  'd' => params[:group_d],
  'E' => params[:group_e].upcase,
  'e' => params[:group_e],
  'F' => params[:group_f].upcase,
  'f' => params[:group_f]
}

# Evaluate repetitions: ...{n}
if pattern =~ REPETITION
  pattern.gsub!(REPETITION) do
    match = $1 != nil ? $1 : $2 != nil ? $2 : $3
    count=$4.to_i
    expanded = ""
    count.times do
      expanded+=match
    end
    expanded
  end
end

# Evaluate character groups [...]
if pattern =~ GROUPS
  pattern.gsub!(GROUPS) do
    $1[rand($1.length)]
  end
end

# Evaluate the final pattern (repetitions and []-groups processed)
password = ""
pattern.each_char do |c|
  password+=group[c][rand(group[c].length)]
end
@password=password;

Моя идея состоит в том, чтобы найти все вхождения и заменить повторения расширенными повторениями, чтобы Ab(ab){5}ccd стало Ababababababccd, которое я потом обрабатываю.

Я предполагаю, что .gsub обрабатывает каждое событие индивидуально, и я могу заменить каждое совпадение подходящим шаблоном и счетчиком. Если gsub попытается заменить их все сразу, это будет неправильный метод.

Для меня не имеет значения, какая из групп в (?:a|b|c){count} соответствует, но совпадение должно быть возвращено как $1, а количество — как $2.

Приведенное выше регулярное выражение приводит к совпадениям $1, $2, $3 и $4. 4 доллара — это всегда мой счет повторений. Но тогда мне нужно выяснить, какие $1 .. $3 не являются nil, и использовать их для расширения. Я мог бы использовать «дешевый» корпус, а если и чехлы, то я хочу иметь элегантное решение.

В regex101 я заставил его работать (?|, но Руби этого не понимает.

Надеюсь, понятно, чего я хочу!?

В Typescript и C# у меня все заработало, и теперь я хочу, чтобы оно работало в Ruby... :-)