Regex does not check the first character after first check - ruby-on-rails

Question

I am trying to write a regex that:
Allows only numbers, lowercase letters and also "-" and "_".
String can only start with: letter number or "uuid:"
String must have at least one letter in it.
It must consist of at least 2 characters.
I managed to create such a regex: \A(?:uuid:|[a-z0-9])(?=(.*[a-z])){1,}(?:\w|-)+\z
I just don't understand why if the first character is a letter, it is not taken into account, so it doesn't pass for example: a1.
And also why it allows uppercase letters AA.
Tests: https://rubular.com/r/Q5gEP15iaYkHYQ
Thank you in advance for your help

Answer 1

You could also get the matches without lookarounds using an alternation matching at least 2 characters from the start.
If you don't want to match uppercase chars A-Z, then you can omit /i for case insensitive matching.
\A(?:uuid:|[a-z][a-z0-9_-]|[0-9][0-9_-]*[a-z])[a-z0-9_-]*\z
Explanation
\A Start of string
(?: Non capture group
uuid: match literally
| Or
[a-z][a-z0-9_-] match a char a-z and one of a-z 0-9 _ -
| Or
[0-9][0-9_-]*[a-z] Match a digit, optional chars 0-9 _ - and then a-z
) Close non capture group
[a-z0-9_-]* Match optional chars a-z 0-9 _ -
\z End of string
Regex rubular demo

Answer 2

It looks like AA meets all your requirements: it contains a letter, at least two chars, and starts with a letter, and contains "only numbers, lowercase letters and also - and _". NOTE you have an i flag that makes pattern matching case insensitive, and if you do not want to allow any uppercase letters, just remove it from the end of the regex literal.
To fix the other real issues, you can use
/\A(?=[^a-z]*[a-z])(?=.{2})(?:uuid:|[a-z0-9])[a-z0-9_-]*\z/
See this Rubular demo.
Note that in the demo, (?=[^a-z\n]*[a-z]) is used rather than (?=[^a-z]*[a-z]) because the test is performed on a single multiline string, not an array of separate strings.
Details:
\A - start of string
(?=[^a-z]*[a-z]) - minimum one letter
(?=.{2}) - minimim two chars
(?:uuid:|[a-z0-9]) - uuid:, or one letter or digit
[a-z0-9_-]* - zero or more letters, digits, _ or -
\z - end of string

Answer 3

You can use the following regular expression as the argument of String#match?. I've written the expression in free-spacing mode to make it self-documenting. Free-spacing mode is invoked with the option x (i.e. /x). It causes whitespace and comments to be ignored.
Note that I've defined named capture group common_code so that I can use its instructions as a subexpression (a.k.a. subroutine) in subsequent instructions. The invocation \g<common_code> tells Ruby to repeat the instructions in that capture group. See Subexpression Calls. You will see that numbered capture groups can be used as well.
The use of subexpressions has three benefits:
less code is required;
there is less chance of making errors, both when initially forming the expression and later when modifying it, by confining all instructions that are to repeat through the expression in one place (in the capture group); and
it makes the expression easier to read and understand.
re = /
\A # match the beginning of the string
(?: # begin a non-capture group
[a-z] # match a lc letter
(?<common_code> # begin a capture group named 'common_code'
[\da-z_-] # match a digit, lc letter, underscore or hyphen
) # end capture group
+ # execute the preceding capture group or more times
| # or
uuid: # match a string literal
\g<common_code>* # match code in capture group common_code >= 0 times
| # or
\d # match a digit
\g<common_code>* # match code in capture group common_code >= 0 times
[a-z] # match a lc letter
\g<common_code>* # match code in capture group common_code >= 0 times
) # end the non-capture group
\z # match the end of the string
/x # invoke free-spacing regex definition mode
test = %w| ab a1 a_ a- 0a 01a 0_a 0-a uuid: uuid:a uuid:0 uuid:_ uuid:- | +
%w| a _a -a a$ auuid: 01 0_ 0- 01_- |
test.each do |s|
puts "#{s.ljust(7)} -> #{s.match?(re)}"
end
ab -> true
a1 -> true
a_ -> true
a- -> true
0a -> true
01a -> true
0_a -> true
0-a -> true
uuid: -> true
uuid:a -> true
uuid:0 -> true
uuid:_ -> true
uuid:- -> true
a -> false
_a -> false
-a -> false
a$ -> false
auuid: -> false
01 -> false
0_ -> false
0- -> false
01_- -> false