mirror of
https://github.com/project-zot/zot.git
synced 2024-12-16 21:56:37 -05:00
af77876306
Go version changed to 1.14.4 Golangci-lint changed to 1.26.0 Bazel version changed to 3.0.0 Bazel rules_go version changed to 0.23.3 Bazel gazelle version changed to v0.21.0 Bazel build tools version changed to 0.25.1 Bazel skylib version changed to 1.0.2
73 lines
2.2 KiB
Go
73 lines
2.2 KiB
Go
package api
|
|
|
|
import "regexp"
|
|
|
|
// nolint: gochecknoglobals
|
|
var (
|
|
// alphaNumericRegexp defines the alpha numeric atom, typically a
|
|
// component of names. This only allows lower case characters and digits.
|
|
alphaNumericRegexp = match(`[a-z0-9]+`)
|
|
|
|
// separatorRegexp defines the separators allowed to be embedded in name
|
|
// components. This allow one period, one or two underscore and multiple
|
|
// dashes.
|
|
separatorRegexp = match(`(?:[._]|__|[-]*)`)
|
|
|
|
// nameComponentRegexp restricts registry path component names to start
|
|
// with at least one letter or number, with following parts able to be
|
|
// separated by one period, one or two underscore and multiple dashes.
|
|
nameComponentRegexp = expression(
|
|
alphaNumericRegexp,
|
|
optional(repeated(separatorRegexp, alphaNumericRegexp)))
|
|
|
|
// NameRegexp is the format for the name component of references. The
|
|
// regexp has capturing groups for the domain and name part omitting
|
|
// the separating forward slash from either.
|
|
NameRegexp = expression(
|
|
nameComponentRegexp,
|
|
optional(repeated(literal(`/`), nameComponentRegexp)))
|
|
)
|
|
|
|
// match compiles the string to a regular expression.
|
|
// nolint (gochecknoglobals)
|
|
var match = regexp.MustCompile
|
|
|
|
// literal compiles s into a literal regular expression, escaping any regexp
|
|
// reserved characters.
|
|
func literal(s string) *regexp.Regexp {
|
|
re := match(regexp.QuoteMeta(s))
|
|
|
|
if _, complete := re.LiteralPrefix(); !complete {
|
|
panic("must be a literal")
|
|
}
|
|
|
|
return re
|
|
}
|
|
|
|
// expression defines a full expression, where each regular expression must
|
|
// follow the previous.
|
|
func expression(res ...*regexp.Regexp) *regexp.Regexp {
|
|
var s string
|
|
for _, re := range res {
|
|
s += re.String()
|
|
}
|
|
|
|
return match(s)
|
|
}
|
|
|
|
// optional wraps the expression in a non-capturing group and makes the
|
|
// production optional.
|
|
func optional(res ...*regexp.Regexp) *regexp.Regexp {
|
|
return match(group(expression(res...)).String() + `?`)
|
|
}
|
|
|
|
// repeated wraps the regexp in a non-capturing group to get one or more
|
|
// matches.
|
|
func repeated(res ...*regexp.Regexp) *regexp.Regexp {
|
|
return match(group(expression(res...)).String() + `+`)
|
|
}
|
|
|
|
// group wraps the regexp in a non-capturing group.
|
|
func group(res ...*regexp.Regexp) *regexp.Regexp {
|
|
return match(`(?:` + expression(res...).String() + `)`)
|
|
}
|