Add named groups for python

python/cucumber_expressions/argument.py

@@ -1,42 +1,52 @@
 from __future__ import annotations
 
-from typing import Optional, List
+from typing import Optional, List, Tuple
 
-from cucumber_expressions.group import Group
 from cucumber_expressions.parameter_type import ParameterType
-from cucumber_expressions.tree_regexp import TreeRegexp
+from cucumber_expressions.tree_regexp import TreeRegexp, Group
 from cucumber_expressions.errors import CucumberExpressionError
 
 
 class Argument:
-    def __init__(self, group, parameter_type):
-        self._group: Group = group
-        self.parameter_type: ParameterType = parameter_type
+    def __init__(
+        self, group: Group, parameter_type: ParameterType, name: Optional[str]
+    ):
+        self.group = group
+        self.parameter_type = parameter_type
+        self.name = name
 
     @staticmethod
     def build(
-        tree_regexp: TreeRegexp, text: str, parameter_types: List
+        tree_regexp: TreeRegexp,
+        text: str,
+        parameter_types_and_names: List[Tuple[ParameterType, Optional[str]]],
     ) -> Optional[List[Argument]]:
+        # Check if all elements in parameter_types_and_names are tuples
+        for item in parameter_types_and_names:
+            if not isinstance(item, tuple) or len(item) != 2:
+                raise CucumberExpressionError(
+                    f"Expected a tuple of (ParameterType, Optional[str]), but got {type(item)}: {item}"
+                )
+
         match_group = tree_regexp.match(text)
         if not match_group:
             return None
 
         arg_groups = match_group.children
 
-        if len(arg_groups) != len(parameter_types):
+        if len(arg_groups) != len(parameter_types_and_names):
+            param_count = len(parameter_types_and_names)
             raise CucumberExpressionError(
-                f"Group has {len(arg_groups)} capture groups, but there were {len(parameter_types)} parameter types"
+                f"Group has {len(arg_groups)} capture groups, but there were {param_count} parameter types/names"
             )
 
         return [
-            Argument(arg_group, parameter_type)
-            for parameter_type, arg_group in zip(parameter_types, arg_groups)
+            Argument(arg_group, parameter_type, parameter_name)
+            for (parameter_type, parameter_name), arg_group in zip(
+                parameter_types_and_names, arg_groups
+            )
         ]
 
     @property
     def value(self):
         return self.parameter_type.transform(self.group.values if self.group else None)
-
-    @property
-    def group(self):
-        return self._group

python/cucumber_expressions/ast.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Optional, List
+from typing import Optional, List, Any
 
 
 class NodeType(Enum):
@@ -78,7 +78,7 @@ def end(self) -> int:
     def text(self) -> str:
         return self.token or "".join([node_value.text for node_value in self.nodes])
 
-    def to_json(self):
+    def to_json(self) -> dict[str, Any]:
         json_obj = {"type": self.ast_type.value}
         if self.nodes is not None:
             json_obj["nodes"] = [node_value.to_json() for node_value in self.nodes]
@@ -140,7 +140,7 @@ def type_of(char: str) -> TokenType:
         return TokenType.TEXT
 
     @staticmethod
-    def symbol_of(token: TokenType):
+    def symbol_of(token: TokenType) -> str:
         possible_token_character_key = token.name + "_CHARACTER"
         if any(
             e.name
@@ -151,7 +151,7 @@ def symbol_of(token: TokenType):
         return ""
 
     @staticmethod
-    def purpose_of(token: TokenType):
+    def purpose_of(token: TokenType) -> str:
         if token in [TokenType.BEGIN_OPTIONAL, TokenType.END_OPTIONAL]:
             return "optional text"
         if token in [TokenType.BEGIN_PARAMETER, TokenType.END_PARAMETER]:
@@ -160,7 +160,7 @@ def purpose_of(token: TokenType):
             return "alternation"
         return ""
 
-    def to_json(self):
+    def to_json(self) -> dict[str, Any]:
         return {
             "type": self.ast_type.value,
             "text": self.text,

python/cucumber_expressions/expression.py

@@ -1,33 +1,34 @@
-from typing import Optional, List
+from typing import Optional, List, Tuple
 
 from cucumber_expressions.argument import Argument
 from cucumber_expressions.ast import Node, NodeType
 from cucumber_expressions.expression_parser import CucumberExpressionParser
 from cucumber_expressions.parameter_type import ParameterType
+from cucumber_expressions.parameter_type_registry import ParameterTypeRegistry
 from cucumber_expressions.tree_regexp import TreeRegexp
 from cucumber_expressions.errors import (
-    UndefinedParameterTypeError,
     ParameterIsNotAllowedInOptional,
     OptionalIsNotAllowedInOptional,
     OptionalMayNotBeEmpty,
     AlternativeMayNotBeEmpty,
     AlternativeMayNotExclusivelyContainOptionals,
+    UndefinedParameterTypeError,
 )
 
 ESCAPE_PATTERN = rb"([\\^\[({$.|?*+})\]])"
 
 
 class CucumberExpression:
-    def __init__(self, expression, parameter_type_registry):
+    def __init__(self, expression: str, parameter_type_registry: ParameterTypeRegistry):
         self.expression = expression
         self.parameter_type_registry = parameter_type_registry
-        self.parameter_types: List[ParameterType] = []
+        self.parameter_types_and_names: List[Tuple[ParameterType, Optional[str]]] = []
         self.tree_regexp = TreeRegexp(
             self.rewrite_to_regex(CucumberExpressionParser().parse(self.expression))
         )
 
     def match(self, text: str) -> Optional[List[Argument]]:
-        return Argument.build(self.tree_regexp, text, self.parameter_types)
+        return Argument.build(self.tree_regexp, text, self.parameter_types_and_names)
 
     @property
     def source(self):
@@ -57,23 +58,21 @@ def rewrite_to_regex(self, node: Node):
     def escape_regex(expression) -> str:
         return expression.translate({i: "\\" + chr(i) for i in ESCAPE_PATTERN})
 
-    def rewrite_optional(self, node: Node):
-        _possible_node_with_params = self.get_possible_node_with_parameters(node)
-        if _possible_node_with_params:
+    def rewrite_optional(self, node: Node) -> str:
+        if self.get_possible_node_with_parameters(node):
             raise ParameterIsNotAllowedInOptional(
-                _possible_node_with_params, self.expression
+                self.get_possible_node_with_parameters(node), self.expression
             )
-        _possible_node_with_optionals = self.get_possible_node_with_optionals(node)
-        if _possible_node_with_optionals:
+        if self.get_possible_node_with_optionals(node):
             raise OptionalIsNotAllowedInOptional(
-                _possible_node_with_optionals, self.expression
+                self.get_possible_node_with_optionals(node), self.expression
             )
         if self.are_nodes_empty(node):
             raise OptionalMayNotBeEmpty(node, self.expression)
         regex = "".join([self.rewrite_to_regex(_node) for _node in node.nodes])
         return rf"(?:{regex})?"
 
-    def rewrite_alternation(self, node: Node):
+    def rewrite_alternation(self, node: Node) -> str:
         for alternative in node.nodes:
             if not alternative.nodes:
                 raise AlternativeMayNotBeEmpty(alternative, self.expression)
@@ -87,20 +86,34 @@ def rewrite_alternation(self, node: Node):
     def rewrite_alternative(self, node: Node):
         return "".join([self.rewrite_to_regex(_node) for _node in node.nodes])
 
-    def rewrite_parameter(self, node: Node):
+    def rewrite_parameter(self, node: Node) -> str:
         name = node.text
-        parameter_type = self.parameter_type_registry.lookup_by_type_name(name)
+        group_name, parameter_type = self.parse_parameter_name(name)
 
         if not parameter_type:
             raise UndefinedParameterTypeError(node, self.expression, name)
 
-        self.parameter_types.append(parameter_type)
+        self.parameter_types_and_names.append((parameter_type, group_name))
 
         regexps = parameter_type.regexps
         if len(regexps) == 1:
             return rf"({regexps[0]})"
         return rf"((?:{')|(?:'.join(regexps)}))"
 
+    def parse_parameter_name(
+        self, name: str
+    ) -> Tuple[Optional[str], Optional[ParameterType]]:
+        """Helper function to parse the parameter name and return group_name and parameter_type."""
+        if ":" in name:
+            group_name, parameter_type_name = [part.strip() for part in name.split(":")]
+            parameter_type = self.parameter_type_registry.lookup_by_type_name(
+                parameter_type_name
+            )
+        else:
+            group_name = None
+            parameter_type = self.parameter_type_registry.lookup_by_type_name(name)
+        return group_name, parameter_type
+
     def rewrite_expression(self, node: Node):
         regex = "".join([self.rewrite_to_regex(_node) for _node in node.nodes])
         return rf"^{regex}$"

python/cucumber_expressions/expression_factory.py

@@ -0,0 +1,39 @@
+import re
+
+from cucumber_expressions.expression import CucumberExpression
+from cucumber_expressions.parameter_type_registry import ParameterTypeRegistry
+from cucumber_expressions.regular_expression import RegularExpression
+
+CURLY_BRACKET_PATTERN = re.compile(r"{(.*?)}")
+INVALID_CURLY_PATTERN = re.compile(r"^\d+(?:,\d+)?$")
+
+
+class ExpressionFactory:
+    def __init__(
+        self, parameter_type_registry: ParameterTypeRegistry = ParameterTypeRegistry()
+    ):
+        self.parameter_type_registry = parameter_type_registry
+
+    @staticmethod
+    def _has_curly_brackets(string: str) -> bool:
+        return "{" in string and "}" in string
+
+    @staticmethod
+    def _extract_text_in_curly_brackets(string: str) -> list:
+        return CURLY_BRACKET_PATTERN.findall(string)
+
+    def is_cucumber_expression(self, expression_string: str):
+        if not self._has_curly_brackets(expression_string):
+            return False
+        bracket_texts = self._extract_text_in_curly_brackets(expression_string)
+        # Check if any match does not contain an integer or an integer and a comma
+        for text in bracket_texts:
+            # Check if the match is a regex pattern (matches integer or integer-comma pattern)
+            if INVALID_CURLY_PATTERN.match(text):
+                return False  # Found a form of curly bracket
+        return True  # All curly brackets are valid
+
+    def create_expression(self, expression_string: str):
+        if self.is_cucumber_expression(expression_string):
+            return CucumberExpression(expression_string, self.parameter_type_registry)
+        return RegularExpression(expression_string, self.parameter_type_registry)

python/cucumber_expressions/expression_generator.py

@@ -8,10 +8,11 @@
 from cucumber_expressions.combinatorial_generated_expression_factory import (
     CombinatorialGeneratedExpressionFactory,
 )
+from cucumber_expressions.parameter_type_registry import ParameterTypeRegistry
 
 
 class CucumberExpressionGenerator:
-    def __init__(self, parameter_type_registry):
+    def __init__(self, parameter_type_registry: ParameterTypeRegistry):
         self.parameter_type_registry = parameter_type_registry
 
     def generate_expressions(self, text: str) -> List[GeneratedExpression]:

python/cucumber_expressions/expression_parser.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import NamedTuple, Optional, Callable, List
+from typing import NamedTuple, Optional, Callable, List, Tuple, Union
 
 from cucumber_expressions.ast import Token, TokenType, Node, NodeType
 from cucumber_expressions.errors import (
@@ -171,7 +171,7 @@ def parse_between(
         begin_token: TokenType,
         end_token: TokenType,
         parsers: List,
-    ) -> Callable[[Parser], Result | tuple[int, Node]]:
+    ) -> Callable[[Parser], Union[Result, Tuple[int, Node]]]:
         def _parse_between(parser: Parser):
             if not self.looking_at(parser.tokens, parser.current, begin_token):
                 return Result(0, None)
@@ -221,7 +221,7 @@ def parse_tokens_until(
         tokens: List[Token],
         start_at: int,
         end_tokens: List[TokenType],
-    ) -> tuple[int, List[Node]]:
+    ) -> Tuple[int, List[Node]]:
         current = start_at
         size = len(tokens)
         ast: List[Node] = []

python/cucumber_expressions/group.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
-from typing import List
+from typing import List, Optional
 
 
 class Group:
-    def __init__(self, value: str, start: int, end: int, children: List[Group]):
+    def __init__(
+        self,
+        value: str,
+        start: int,
+        end: int,
+        children: List[Group],
+        name: Optional[str] = None,
+    ):
         self._children = children
         self._value = value
         self._start = start
         self._end = end
+        self.name = name
 
     @property
     def value(self):

python/cucumber_expressions/group_builder.py

@@ -16,12 +16,16 @@ def __init__(self):
     def add(self, group_builder: GroupBuilder):
         self._group_builders.append(group_builder)
 
-    def build(self, match, group_indices) -> Group:
+    def build(self, match, group_indices, group_name_map: dict) -> Group:
         group_index = next(group_indices)
-        children: List[Group] = [
-            gb.build(match, group_indices) for gb in self._group_builders
+        group_name = group_name_map.get(group_index, None)
+
+        children = [
+            gb.build(match, group_indices, group_name_map)
+            for gb in self._group_builders
         ]
         return Group(
+            name=group_name,
             value=match.group(group_index),
             start=match.regs[group_index][0],
             end=match.regs[group_index][1],

python/cucumber_expressions/parameter_type.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Callable, Optional, Pattern
+from typing import Callable, Optional, Pattern, Union, List
 
 from cucumber_expressions.errors import CucumberExpressionError
 
@@ -44,8 +44,8 @@ def compare(pt1: ParameterType, pt2: ParameterType):
 
     def __init__(
         self,
-        name,
-        regexp,
+        name: str | None,
+        regexp: Union[List[str], str, List[Pattern], Pattern],
         type,
         transformer: Optional[Callable] = None,
         use_for_snippets: bool = True,
@@ -96,9 +96,11 @@ def _get_regexp_source(regexp_pattern: Pattern) -> str:
                 )
         return regexp_pattern.pattern
 
-    def to_array(self, regexps: list[str] | str | list[Pattern] | Pattern) -> list[str]:
+    def to_array(
+        self, regexps: Union[List[str], str, List[Pattern], Pattern]
+    ) -> List[str]:
         """Make a list of regexps if not already"""
-        array: list = regexps if isinstance(regexps, list) else [regexps]
+        array: List = regexps if isinstance(regexps, list) else [regexps]
         return [
             regexp if isinstance(regexp, str) else self._get_regexp_source(regexp)
             for regexp in array