Re-factor repetition production class to use an optional separator

Addition of a `separator` parameter allows arguably a neater taxonomy of production classes, with `CommaSeparatedRepetitionProduction` now extending `RepetitionProduction` and using a separator value. This also will allow expressing repetition productions that employ arbitrary separators. It also reduces amount of code required for expressing productions of both kinds and then some.

Author: amn

src/csspring/selectors.py

@@ -67,29 +67,6 @@ def parse_any_value(input: TokenStream) -> Product | None:
     else:
         return None
 
-@parse.register
-def _(production: CommaSeparatedRepetitionProduction, input: TokenStream) -> Product | None:
-    """Variant of `parse` for productions of the `#` multiplier variety (see https://drafts.csswg.org/css-values-4/#mult-comma)."""
-    result: list[Product | Token] = []
-    input.mark()
-    while True:
-        value: Product | Token | None
-        if result:
-            value = parse(production.delimiter, input)
-            if value is None:
-                break
-            result.append(value)
-        value = parse(production.element, input)
-        if value is None:
-            break
-        result.append(value)
-    if result:
-        input.discard_mark()
-        return result
-    else:
-        input.restore_mark()
-        return None
-
 @parse.register
 def _(production: ConcatenationProduction, input: TokenStream) -> Product | None:
     """Variant of `parse` for productions of the ` ` combinator variety (see "juxtaposing components" at https://drafts.csswg.org/css-values-4/#component-combinators)."""
@@ -126,9 +103,21 @@ def _(production: RepetitionProduction, input: TokenStream) -> Product | None:
     result: list[Product | Token] = []
     input.mark()
     while True:
+        if result and production.separator:
+            input.mark()
+            separator = parse(production.separator, input)
+            if separator is None:
+                input.restore_mark()
+                break
         value = parse(production.element, input)
         if value is None:
+            if result and production.separator:
+                input.restore_mark()
             break
+        if result and production.separator:
+            assert separator is not None
+            result.append(separator)
+            input.discard_mark()
         result.append(value)
         if len(result) == production.max:
             break

src/csspring/values.py

@@ -80,21 +80,25 @@ class RepetitionProduction(Production):
 
 	Implements the `*` notation as defined at http://drafts.csswg.org/css-values-4/#mult-zero-plus.
 	"""
+	separator: Production | None = None
 	element: Production
 	min: int
 	max: int | None
-	def __init__(self, element: Production, min: int = 0, max: int | None = None):
+	def __init__(self, element: Production, min: int = 0, max: int | None = None, *, separator: Production | None = None):
 		"""
 		:param element: The production expressing the repeating part of this production
 		:param min: The minimum amount of times the parser must accept input, i.e. the minimum number of repetitions of token sequences accepted by the parser
 		:param max: The maximum amount of times the parser will be called, i.e. the maximum number of repetitions that may be consumed in the input; the value of `None` implies no maximum (i.e. no upper bound on repetition)
+		:param separator: A production expressing the "delimiting" part between any two repetitions of the `element` production; if omitted or `None`, there's _no_ delimiting part -- repetitions are _adjacent_
 		"""
 		assert min >= 0
 		assert max is None or max > 0
 		assert max is None or min <= max
 		self.min = min
 		self.max = max
 		self.element = element
+		if separator:
+			self.separator = separator
 
 class OptionalProduction(RepetitionProduction):
 	"""Class of productions equivalent to `RepetitionProduction` with no lower bound and accepting no repetition of the element, meaning the element is expressed at most once.
@@ -117,22 +121,18 @@ def __init__(self, type: builtins.type[Token], **attributes):
 		self.type = type
 		self.attributes = attributes
 
+OWS = optional_whitespace = RepetitionProduction(TokenProduction(WhitespaceToken))
 whitespace = RepetitionProduction(TokenProduction(WhitespaceToken), min=1) # The white-space production; presence of white-space expressed with this production, is _mandatory_ (`min=1`); the definition was "hoisted" here because a) it depends on `RepetitionProduction` and `TokenProduction` definitions, which must thus precede it, and b) because the `CommaSeparatedRepetitionParser` definition that follows, depends on it, in turn
 
-class CommaSeparatedRepetitionProduction(Production):
+class CommaSeparatedRepetitionProduction(RepetitionProduction):
 	"""Class of productions that express a non-empty comma-separated repetition (CSR) of a production element.
 
-	Unlike `RepetitionProduction` which permits arbitrary number of the production element, this class does not currently implement arbitrary repetition bounds. The delimiting part (a comma optionally surrounded by white-space) is mandatory, which implies at least one repetition (two expressions of the element). Disregarding the delimiting behaviour, productions of this class thus behave like those of `RepetitionProduction` with `2` for `min` and `None` for `max` property values.
-
 	Implements the `#` notation as defined at http://drafts.csswg.org/css-values-4/#mult-comma.
 	"""
-	delimiter = ConcatenationProduction(OptionalProduction(AlternativesProduction(whitespace, TokenProduction(CommentToken))), TokenProduction(CommaToken), OptionalProduction(AlternativesProduction(whitespace, TokenProduction(CommentToken)))) # The production expressing the delimiter to use with the repetition, a comma with [optional] white-space around it
-	element: Production
-	def __init__(self, element: Production):
-		"""
-		:param element: A production to use for expressing the repeating part in this production
-		"""
-		self.element = element
+	separator = ConcatenationProduction(OWS, TokenProduction(CommaToken), OWS) # A comma with [optional] white-space around it
+	def __init__(self, element: Production, min: int = 1, max: int | None = None):
+		assert min >= 1 # "one or more times" (ref. definition); the spec. does not define whether a minimum of zero is permitted, so we err on the safer side
+		super().__init__(element, min, max)
 
 class Formatter:
 	"""Class of objects that offer procedures for serializing productions into streams of text formatted per the [value definition syntax](https://drafts.csswg.org/css-values-4/#value-defs)."""