Bash posix regex optional groups

Question

Trying to match some Gentoo package naming components from strings in forms category/name-version, due to its complexity, I have come to this:

if [[ "$1" =~ ^([<>]?=?)(([^\/]+)\/)?([^[:space:]]+)-(([[:digit:]]+)?(\.([[:digit:]]+))*([a-z])?(_(alpha|beta|pre|rc|p)([[:digit:]]*))*(-(r([[:digit:]]+))?)?)?$ ]]; then
    # use "${BASH_REMATCH[n]}" here to capture groups contents
fi

It splits strings like <category/package-name-12345.25b_rc10-r7 as expected:

Version specifier: <
Category: category
Package name: package-name
Version: 12345.25b_rc10-r7
Version, major: 12345
Version, minor: 25
Version, letter: b
Version, patch type: rc
Version, patch level: 10
Version, revision number: 7

Now, I need to match and split stings that may have version missing, like category/package-name.

So, is there a way to make the version part above optional?

Above, this part is the following:

-(([[:digit:]]+)?(\.([[:digit:]]+))*([a-z])?(_(alpha|beta|pre|rc|p)([[:digit:]]*))*(-(r([[:digit:]]+))?)?)?

I've tried to change it as:

(-(([[:digit:]]+)?(\.([[:digit:]]+))*([a-z])?(_(alpha|beta|pre|rc|p)([[:digit:]]*))*(-(r([[:digit:]]+)))?))?

It works for a string without a version, but there seem that optional groups prevent it to match a slightly complete string like above and it gets:

Version specifier: 
Category: category
Package name: package-name-12345.25b_rc10-r7
Version: 
Version, major: 
Version, minor: 
Version, letter: 
Version, patch type: 
Version, patch level: 
Version, revision number:

EDIT: Slots

What about two optional parts?

Additionally to the above, must match slots. Slots would be matched like this:

:(([[:digit:]]+)(\.([[:digit:]]+))*)?

Now, there are a category/name part:

([<>]?=?)(([^\/]+)\/)?([^[:space:]]+)

followed by either a version: -(([[:digit:]]+)(\.([[:digit:]]+))*)([a-z])?(_(alpha|beta|pre|rc|p)([[:digit:]]*))*(-(r([[:digit:]]+))?)?

a slot :(([[:digit:]]+)(\.([[:digit:]]+))*)?

or both, version and slot, in this order.

Note, a version starts with the -, as separator, and a slot starts with the :, as separator.

All I can think of is:

if [[ "$1" =~ ^${CATEGORY_PACKAGE}-${VERSION}:${SLOT}$ ]] ; then
    # use "${BASH_REMATCH[n]}" here to capture groups contents
else
    if [[ "$1" =~ ^${CATEGORY_PACKAGE}:${SLOT}$ ]] ; then
        # use "${BASH_REMATCH[n]}" here to capture groups contents
    else
        if [[ "$1" =~ ^${CATEGORY_PACKAGE}-${VERSION}$ ]] || [[ "$1" =~ ^${CATEGORY_PACKAGE}$ ]] ; then
        # use "${BASH_REMATCH[n]}" here to capture groups contents
        fi
    fi
fi

Is this a full solution? Is there a better version? Is there a POSIX solution based on options, like <category-name>(<slot option>|<version option>|<version:slot> option)?

EDIT:

I think bash can handle optional groups in one expression, but I fail to change ([^[:space:]:]+) to handle a hyphen. How can hyphen be included as does not seem to work neither as the first, nor the last in the range?

Answer 1

For the sake of sanity, in situations like this, IMO it's better to just use multiple regular expressions instead of stuffing every possible situation into a single regex:

base_package_name_regex='^([<>]?=?)(([^/]+)/)?([^[:space:]]+)'
version_regex='(([[:digit:]]+)?(\.([[:digit:]]+))*([a-z])?(_(alpha|beta|pre|rc|p)([[:digit:]]*))*(-(r([[:digit:]]+))?)?)?$ '
if [[ "$1" =~ $base_package_name_regex-$version_regex ]] || # package with version number
    [[ "$1" =~ $base_package_name_regex ]]  #  package without version number

then
    # use "${BASH_REMATCH[n]}" here to capture groups contents
fi

Also note that in POSIX ERE, what \/ matches is unspecified and [^\/] matches any character other than backslash or slash. I've removed those spurious backslashes.

Answer 2

If you have to use a shell, you could switch to zsh. Then you can use PCREs instead of POSIX EREs with which

• you get non-greedy operators which you need here for [^[:space:]]+ (which we can shorten to \S+ in PCRE and which we change to the non-greedy \S+? variant) not to gobble everything up to the end leaving no chance for the version to be matched
• you can make the regexp more legible with (?x)
• capture only what you need to capture (using (?: ...) for non-capturing groups).

set -o rematchpcre
field_names=(
  version_specifier
  category
  package
  version
  major
  minor
  letter
  patch_type
  patch_level
  revision
)

typeset -A fields

if [[ $1 =~ '(?x)
  ^
  (?<version_specifier> [<>]? =? )
  (?: (?<category> [^/]+ ) / )?
  (?<package> \S+? )
  (?:
    -
    (?<version>
      (?<major> \d* )
      (?: \. (?<minor> \d+ ) )*
      (?<letter> [a-z] )?
      (?:
    _(?<patch_type> alpha|beta|pre|rc|p )
    (?<patch_level> \d* )
      )*
      (?: - (?: r (?<revision> \d+ ) )? )?
    )?
  )?
  \z' ]]; then
  fields=( "${(@)field_names:^match}" )
  typeset -p fields
fi

Note that we name the capture groups here with (?<name> ...) but that's only for documentation purposes, the capture groups are stored in the simple $match array, zsh doesn't support retrieving them by name like the %+{name} of perl.

Here that script gives:

$ ./that-script '<category/package-name-12345.25b_rc10-r7'
typeset -A fields=(
 [category]=category
 [letter]=b
 [major]=12345
 [minor]=25
 [package]=package-name
 [patch_level]=10
 [patch_type]=rc
 [revision]=7
 [version]=12345.25b_rc10-r7
 [version_specifier]='<'
)
$ ./that-script '<category/package-name'
typeset -A fields=(
 [category]=category
 [package]=package-name
 [version_specifier]='<'
)
$ ./that-script package-name
typeset -A fields=(
 [category]=''
 [package]=package-name
 [version_specifier]=''
)