First commit: add named groups for python

Author: jsa34

python/cucumber_expressions/argument.py

@@ -1,42 +1,45 @@
 from __future__ import annotations
 
-from typing import Optional, List
+from typing import Optional
 
-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
-    ) -> Optional[List[Argument]]:
+        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):
             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 {len(parameter_types_and_names)} 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, Any
 
 
 class NodeType(Enum):
@@ -41,44 +41,24 @@ class Node:
     def __init__(
         self,
         ast_type: NodeType,
-        nodes: Optional[List[Node]],
+        nodes: Optional[list[Node]],
         token: Optional[str],
         start: int,
         end: int,
     ):
         if nodes is None and token is None:
             raise Exception("Either nodes or token must be defined")
-        self._ast_type = ast_type
-        self._nodes = nodes
-        self._token = token
-        self._start = start
-        self._end = end
-
-    @property
-    def ast_type(self) -> NodeType:
-        return self._ast_type
-
-    @property
-    def nodes(self) -> List[Node]:
-        return self._nodes
-
-    @property
-    def token(self) -> str:
-        return self._token
-
-    @property
-    def start(self) -> int:
-        return self._start
-
-    @property
-    def end(self) -> int:
-        return self._end
+        self.ast_type = ast_type
+        self.nodes = nodes
+        self.token = token
+        self.start = start
+        self.end = end
 
     @property
     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]
@@ -91,26 +71,10 @@ def to_json(self):
 
 class Token:
     def __init__(self, ast_type: TokenType, text: str, start: int, end: int):
-        self._ast_type = ast_type
-        self._text = text
-        self._start = start
-        self._end = end
-
-    @property
-    def ast_type(self):
-        return self._ast_type
-
-    @property
-    def text(self):
-        return self._text
-
-    @property
-    def start(self):
-        return self._start
-
-    @property
-    def end(self):
-        return self._end
+        self.ast_type = ast_type
+        self.text = text
+        self.start = start
+        self.end = end
 
     @staticmethod
     def is_escape_character(char: str) -> bool:
@@ -140,7 +104,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 +115,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 +124,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/combinatorial_generated_expression_factory.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from cucumber_expressions.generated_expression import GeneratedExpression
 from cucumber_expressions.parameter_type import ParameterType
 
@@ -12,16 +10,16 @@ def __init__(self, expression_template, parameter_type_combinations):
         self.expression_template = expression_template
         self.parameter_type_combinations = parameter_type_combinations
 
-    def generate_expressions(self) -> List[GeneratedExpression]:
+    def generate_expressions(self) -> list[GeneratedExpression]:
         generated_expressions = []
         self.generate_permutations(generated_expressions, 0, [])
         return generated_expressions
 
     def generate_permutations(
         self,
-        generated_expressions: List[GeneratedExpression],
+        generated_expressions: list[GeneratedExpression],
         depth: int,
-        current_parameter_types: List[ParameterType],
+        current_parameter_types: list[ParameterType],
     ):
         if len(generated_expressions) >= MAX_EXPRESSIONS:
             return

python/cucumber_expressions/expression.py

@@ -1,33 +1,33 @@
-from typing import Optional, List
+from typing import Optional
 
 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,
+    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)
+    def match(self, text: str) -> Optional[list[Argument]]:
+        return Argument.build(self.tree_regexp, text, self.parameter_types_and_names)
 
     @property
     def source(self):
@@ -57,23 +57,17 @@ 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:
-            raise ParameterIsNotAllowedInOptional(
-                _possible_node_with_params, self.expression
-            )
-        _possible_node_with_optionals = self.get_possible_node_with_optionals(node)
-        if _possible_node_with_optionals:
-            raise OptionalIsNotAllowedInOptional(
-                _possible_node_with_optionals, self.expression
-            )
+    def rewrite_optional(self, node: Node) -> str:
+        if self.get_possible_node_with_parameters(node):
+            raise ParameterIsNotAllowedInOptional(self.get_possible_node_with_parameters(node), self.expression)
+        if self.get_possible_node_with_optionals(node):
+            raise OptionalIsNotAllowedInOptional(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 +81,30 @@ 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 = 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}$"
@@ -117,5 +121,5 @@ def get_possible_node_with_optionals(self, node: Node) -> Optional[Node]:
         return results[0] if results else None
 
     @staticmethod
-    def get_nodes_with_ast_type(node: Node, ast_type: NodeType) -> List[Node]:
+    def get_nodes_with_ast_type(node: Node, ast_type: NodeType) -> list[Node]:
         return [ast_node for ast_node in node.nodes if ast_node.ast_type == ast_type]

python/cucumber_expressions/expression_factory.py

@@ -0,0 +1,38 @@
+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)