feat: support additional repetition options (#60)

support additional repetition options

_docs/library.md

@@ -97,10 +97,15 @@ Helpers that specify how to repeat characters. They can be called on character c
 
 ```golang
 RepetableClassToken.Repeat().OneOrMore() // `+`
+RepetableClassToken.Repeat().OneOrMorePreferFewer() // `+?`
 RepetableClassToken.ZeroOrMore() // `*`
+RepetableClassToken.ZeroOrMorePreferFewer() // `*?`
 RepetableClassToken.ZeroOrOne() // `?`
+RepetableClassToken.ZeroOrOnePreferZero() // `??`
 RepetableClassToken.EqualOrMoreThan(n int) // `{n,}`
+RepetableClassToken.EqualOrMoreThanPreferFewer(n int) // `{n,}?`
 RepetableClassToken.Between(n, m int) // `{n,m}`
+RepetableClassToken.BetweenPreferFewer(n, m int) // `{n,m}?`
 
 // Example:
 rex.Chars.Digits().Repeat().OneOrMore() // [0-9]+

pkg/dialect/base/repetitions.go

@@ -48,20 +48,41 @@ func (r Repetition) OneOrMore() dialect.Token {
 	return r.withSuffix("+")
 }
 
+// OneOrMorePreferFewer repeats one or more, prefer fewer chars.
+//
+// Regex: `+?`.
+func (r Repetition) OneOrMorePreferFewer() dialect.Token {
+	return r.withSuffix("+?")
+}
+
 // ZeroOrMore repeats zero or more, prefer more chars.
 //
 // Regex: `*`.
 func (r Repetition) ZeroOrMore() dialect.Token {
 	return r.withSuffix("*")
 }
 
-// ZeroOrMore repeats zero or one x, prefer one.
+// ZeroOrMorePreferFewer repeats zero or more, prefer fewer chars.
+//
+// Regex: `*?`.
+func (r Repetition) ZeroOrMorePreferFewer() dialect.Token {
+	return r.withSuffix("*?")
+}
+
+// ZeroOrOne repeats zero or one x, prefer one.
 //
 // Regex: `?`.
 func (r Repetition) ZeroOrOne() dialect.Token {
 	return r.withSuffix("?")
 }
 
+// ZeroOrOnePreferZero repeats zero or one x, prefer zero.
+//
+// Regex: `??`.
+func (r Repetition) ZeroOrOnePreferZero() dialect.Token {
+	return r.withSuffix("??")
+}
+
 // Exactly n times. It doesn't validate an input.
 //
 // Regex: `{n}`.
@@ -77,10 +98,26 @@ func (r Repetition) EqualOrMoreThan(n int) dialect.Token {
 	return r.withSuffix(fmt.Sprintf("{%d,}", n))
 }
 
+// EqualOrMoreThanPreferFewer repeats i or i+1 or ... or n, prefer fewer.
+// It doesn't validate an input.
+//
+// Regex: `{n,}?`.
+func (r Repetition) EqualOrMoreThanPreferFewer(n int) dialect.Token {
+	return r.withSuffix(fmt.Sprintf("{%d,}?", n))
+}
+
 // Between repeats i=from or i+1 or ... or to, prefer more.
 // It doesn't validate an input.
 //
 // Regex: `{from,to}`.
 func (r Repetition) Between(from, to int) dialect.Token {
 	return r.withSuffix(fmt.Sprintf("{%d,%d}", from, to))
 }
+
+// BetweenPreferFewer repeats i=from or i+1 or ... or to, prefer fewer.
+// It doesn't validate an input.
+//
+// Regex: `{from,to}?`.
+func (r Repetition) BetweenPreferFewer(from, to int) dialect.Token {
+	return r.withSuffix(fmt.Sprintf("{%d,%d}?", from, to))
+}

pkg/dialect/base/repetitions_test.go

@@ -1,3 +1,4 @@
+// nolint: funlen // Unit tests.
 package base_test
 
 import (
@@ -20,22 +21,42 @@ func TestRexClassRepetitions(t *testing.T) {
 		Name:     "Between",
 		Chain:    []dialect.Token{getABClass().Between(0, 1)},
 		Expected: `[ab]{0,1}`,
+	}, {
+		Name:     "BetweenPreferFewer",
+		Chain:    []dialect.Token{getABClass().BetweenPreferFewer(0, 1)},
+		Expected: `[ab]{0,1}?`,
 	}, {
 		Name:     "EqualOrMoreThan",
 		Chain:    []dialect.Token{getABClass().EqualOrMoreThan(5)},
 		Expected: `[ab]{5,}`,
+	}, {
+		Name:     "EqualOrMoreThanPreferFewer",
+		Chain:    []dialect.Token{getABClass().EqualOrMoreThanPreferFewer(5)},
+		Expected: `[ab]{5,}?`,
 	}, {
 		Name:     "OneOrMore",
 		Chain:    []dialect.Token{getABClass().OneOrMore()},
 		Expected: `[ab]+`,
 	}, {
-		Name:     "OneOrMore",
+		Name:     "OneOrMorePreferFewer",
+		Chain:    []dialect.Token{getABClass().OneOrMorePreferFewer()},
+		Expected: `[ab]+?`,
+	}, {
+		Name:     "ZeroOrMore",
 		Chain:    []dialect.Token{getABClass().ZeroOrMore()},
 		Expected: `[ab]*`,
+	}, {
+		Name:     "ZeroOrMorePreferFewer",
+		Chain:    []dialect.Token{getABClass().ZeroOrMorePreferFewer()},
+		Expected: `[ab]*?`,
 	}, {
 		Name:     "ZeroOrOne",
 		Chain:    []dialect.Token{getABClass().ZeroOrOne()},
 		Expected: `[ab]?`,
+	}, {
+		Name:     "ZeroOrOnePreferZero",
+		Chain:    []dialect.Token{getABClass().ZeroOrOnePreferZero()},
+		Expected: `[ab]??`,
 	}, {
 		Name:     "AnyOneOrMore",
 		Chain:    []dialect.Token{base.Chars.Any().Repeat().OneOrMore()},
@@ -44,6 +65,10 @@ func TestRexClassRepetitions(t *testing.T) {
 		Name:     "RangeOneOrMore",
 		Chain:    []dialect.Token{base.Chars.Range('0', '9').Repeat().OneOrMore()},
 		Expected: `[0-9]+`,
+	}, {
+		Name:     "RangeOneOrMorePreferFewer",
+		Chain:    []dialect.Token{base.Chars.Range('0', '9').Repeat().OneOrMorePreferFewer()},
+		Expected: `[0-9]+?`,
 	}, {
 		Name:     "Exactly",
 		Chain:    []dialect.Token{base.Chars.Range('0', '9').Repeat().Exactly(2)},