refactor: ruff Python linting over flake8 and black

Run linting workflow through uv and Python 3.13 with a cache.

Author: kieran-ryan

.github/workflows/test-python.yml

@@ -11,27 +11,25 @@ on:
 
 jobs:
   test-python-linting:
+    runs-on: "ubuntu-latest"
+    strategy:
+      fail-fast: false
     defaults:
       run:
         working-directory: python
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-        python-version: ["3.10"]
     steps:
     - uses: actions/checkout@v5
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v6
+
+    - name: Install uv and set the python version
+      uses: astral-sh/setup-uv@v6
       with:
-        python-version: ${{ matrix.python-version }}
+        enable-cache: true
+        python-version: "3.13"
+        version: "0.8.17"
+
     - name: Linting
-      run: |
-        python -m pip install pre-commit
-        pre-commit run --all-files
-        
+      run: uvx pre-commit run --all-files
+
   test-python:
     runs-on: ${{ matrix.os }}
     defaults:

python/.pre-commit-config.yaml

@@ -1,10 +1,6 @@
 repos:
--   repo: https://github.com/psf/black
-    rev: 22.3.0
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.13.0
     hooks:
-    -   id: black
--   repo: https://github.com/PyCQA/flake8
-    rev: 4.0.1
-    hooks:
-    -   id: flake8
-        args: ['--max-line-length=130','--ignore=E203,W503']
+      - id: ruff-check
+      - id: ruff-format

python/cucumber_expressions/argument.py

@@ -14,9 +14,7 @@ def __init__(self, group, parameter_type):
         self.parameter_type: ParameterType = parameter_type
 
     @staticmethod
-    def build(
-        tree_regexp: TreeRegexp, text: str, parameter_types: List
-    ) -> Optional[List[Argument]]:
+    def build(tree_regexp: TreeRegexp, text: str, parameter_types: List) -> Optional[List[Argument]]:
         match_group = tree_regexp.match(text)
         if not match_group:
             return None
@@ -28,10 +26,7 @@ def build(
                 f"Group has {len(arg_groups)} capture groups, but there were {len(parameter_types)} parameter types"
             )
 
-        return [
-            Argument(arg_group, parameter_type)
-            for parameter_type, arg_group in zip(parameter_types, arg_groups)
-        ]
+        return [Argument(arg_group, parameter_type) for parameter_type, arg_group in zip(parameter_types, arg_groups)]
 
     @property
     def value(self):

python/cucumber_expressions/ast.py

@@ -123,17 +123,13 @@ def can_escape(char: str) -> bool:
 
         _escape_chars = [e.value for e in EscapeCharacters]
         _demarcation_chars = [e.value for e in DemarcationCharacters]
-        return any(
-            char == escape_char for escape_char in _escape_chars + _demarcation_chars
-        )
+        return any(char == escape_char for escape_char in _escape_chars + _demarcation_chars)
 
     @staticmethod
     def type_of(char: str) -> TokenType:
         if char.isspace():
             return TokenType.WHITE_SPACE
-        possible_demarcation_match = [
-            e.name for e in DemarcationCharacters if e.value == char
-        ]
+        possible_demarcation_match = [e.name for e in DemarcationCharacters if e.value == char]
         if possible_demarcation_match:
             _key = possible_demarcation_match[0].replace("_CHARACTER", "")
             return TokenType(_key)
@@ -142,11 +138,7 @@ def type_of(char: str) -> TokenType:
     @staticmethod
     def symbol_of(token: TokenType):
         possible_token_character_key = token.name + "_CHARACTER"
-        if any(
-            e.name
-            for e in DemarcationCharacters
-            if e.name == possible_token_character_key
-        ):
+        if any(e.name for e in DemarcationCharacters if e.name == possible_token_character_key):
             return DemarcationCharacters[possible_token_character_key].value
         return ""
 

python/cucumber_expressions/combinatorial_generated_expression_factory.py

@@ -26,15 +26,11 @@ def generate_permutations(
         if len(generated_expressions) >= MAX_EXPRESSIONS:
             return
         if depth == len(self.parameter_type_combinations):
-            generated_expressions.append(
-                GeneratedExpression(self.expression_template, current_parameter_types)
-            )
+            generated_expressions.append(GeneratedExpression(self.expression_template, current_parameter_types))
             return
         for parameter_type_combination in self.parameter_type_combinations[depth]:
             if len(generated_expressions) >= MAX_EXPRESSIONS:
                 return
             new_current_parameter_types = current_parameter_types.copy()
             new_current_parameter_types.append(parameter_type_combination)
-            self.generate_permutations(
-                generated_expressions, depth + 1, new_current_parameter_types
-            )
+            self.generate_permutations(generated_expressions, depth + 1, new_current_parameter_types)

python/cucumber_expressions/errors.py

@@ -1,9 +1,7 @@
 from cucumber_expressions.ast import Token
 
 
-def generate_message(
-    index: int, expression: str, pointer: str, problem: str, solution: str
-):
+def generate_message(index: int, expression: str, pointer: str, problem: str, solution: str):
     return "\n".join(
         [
             f"This Cucumber Expression has a problem at column {index + 1}:",

python/cucumber_expressions/expression.py

@@ -22,9 +22,7 @@ def __init__(self, expression, parameter_type_registry):
         self.expression = expression
         self.parameter_type_registry = parameter_type_registry
         self.parameter_types: List[ParameterType] = []
-        self.tree_regexp = TreeRegexp(
-            self.rewrite_to_regex(CucumberExpressionParser().parse(self.expression))
-        )
+        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)
@@ -60,14 +58,10 @@ def escape_regex(expression) -> str:
     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
-            )
+            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
-            )
+            raise OptionalIsNotAllowedInOptional(_possible_node_with_optionals, 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])
@@ -78,9 +72,7 @@ def rewrite_alternation(self, node: Node):
             if not alternative.nodes:
                 raise AlternativeMayNotBeEmpty(alternative, self.expression)
             if self.are_nodes_empty(alternative):
-                raise AlternativeMayNotExclusivelyContainOptionals(
-                    alternative, self.expression
-                )
+                raise AlternativeMayNotExclusivelyContainOptionals(alternative, self.expression)
         regex = "|".join([self.rewrite_to_regex(_node) for _node in node.nodes])
         return f"(?:{regex})"
 

python/cucumber_expressions/expression_generator.py

@@ -24,46 +24,28 @@ def generate_expressions(self, text: str) -> List[GeneratedExpression]:
 
             def get_matching_parameter_type_matchers():
                 for parameter_type_matcher in parameter_type_matchers:
-                    advanced_parameter_type_matcher = parameter_type_matcher.advance_to(
-                        pos
-                    )
+                    advanced_parameter_type_matcher = parameter_type_matcher.advance_to(pos)
                     if advanced_parameter_type_matcher.find:
                         yield advanced_parameter_type_matcher
 
-            matching_parameter_type_matchers = list(
-                get_matching_parameter_type_matchers()
-            )
+            matching_parameter_type_matchers = list(get_matching_parameter_type_matchers())
             if not matching_parameter_type_matchers:
                 break
 
-            matching_parameter_type_matchers.sort(
-                key=functools.cmp_to_key(ParameterTypeMatcher.compare)
-            )
+            matching_parameter_type_matchers.sort(key=functools.cmp_to_key(ParameterTypeMatcher.compare))
             best_parameter_type_matcher = matching_parameter_type_matchers[0]
             best_parameter_type_matchers = list(
                 filter(
-                    lambda m: ParameterTypeMatcher.compare(
-                        m, best_parameter_type_matcher
-                    )
-                    == 0,
+                    lambda m: ParameterTypeMatcher.compare(m, best_parameter_type_matcher) == 0,
                     matching_parameter_type_matchers,
                 )
             )
             # Filter duplicates
-            parameter_types = {
-                _parameter_type_matcher.parameter_type
-                for _parameter_type_matcher in best_parameter_type_matchers
-            }
-            parameter_type_combinations.append(
-                sorted(parameter_types, key=functools.cmp_to_key(ParameterType.compare))
-            )
-            expression_template.append(
-                self.escape(text[pos : best_parameter_type_matcher.start])
-            )
+            parameter_types = {_parameter_type_matcher.parameter_type for _parameter_type_matcher in best_parameter_type_matchers}
+            parameter_type_combinations.append(sorted(parameter_types, key=functools.cmp_to_key(ParameterType.compare)))
+            expression_template.append(self.escape(text[pos : best_parameter_type_matcher.start]))
             expression_template.append("{%s}")
-            pos = best_parameter_type_matcher.start + len(
-                best_parameter_type_matcher.group
-            )
+            pos = best_parameter_type_matcher.start + len(best_parameter_type_matcher.group)
             if pos >= len(text):
                 break
         expression_template.append(self.escape(text[pos:]))
@@ -73,27 +55,15 @@ def get_matching_parameter_type_matchers():
 
     @staticmethod
     def escape(string: str) -> str:
-        return (
-            string.replace("%", "%%")
-            .replace(r"(", "\\(")
-            .replace(r"{", "\\{")
-            .replace(r"/", "\\/")
-        )
+        return string.replace("%", "%%").replace(r"(", "\\(").replace(r"{", "\\{").replace(r"/", "\\/")
 
     def create_parameter_type_matchers(self, text) -> List[ParameterTypeMatcher]:
         parameter_type_matchers = []
         for parameter_type in self.parameter_type_registry.parameter_types:
             if parameter_type.use_for_snippets:
-                parameter_type_matchers.extend(
-                    self.create_parameter_type_matchers_with_type(parameter_type, text)
-                )
+                parameter_type_matchers.extend(self.create_parameter_type_matchers_with_type(parameter_type, text))
         return parameter_type_matchers
 
     @staticmethod
-    def create_parameter_type_matchers_with_type(
-        parameter_type, text
-    ) -> List[ParameterTypeMatcher]:
-        return [
-            ParameterTypeMatcher(parameter_type, re.compile(f"({regexp})"), text, 0)
-            for regexp in parameter_type.regexps
-        ]
+    def create_parameter_type_matchers_with_type(parameter_type, text) -> List[ParameterTypeMatcher]:
+        return [ParameterTypeMatcher(parameter_type, re.compile(f"({regexp})"), text, 0) for regexp in parameter_type.regexps]

python/cucumber_expressions/expression_parser.py

@@ -23,7 +23,6 @@ class Parser(NamedTuple):
 
 
 class CucumberExpressionParser:
-
     # text == whitespace | ')' | '}' | .
     @staticmethod
     def parse_text(parser: Parser):
@@ -34,9 +33,7 @@ def parse_text(parser: Parser):
             TokenType.END_PARAMETER,
             TokenType.END_OPTIONAL,
         ]:
-            return Result(
-                1, Node(NodeType.TEXT, None, token.text, token.start, token.end)
-            )
+            return Result(1, Node(NodeType.TEXT, None, token.text, token.start, token.end))
         if token.ast_type == TokenType.ALTERNATION:
             raise AlternationNotAllowedInOptional(parser.expression, token)
         # If configured correctly this will never happen
@@ -47,9 +44,7 @@ def parse_text(parser: Parser):
     def parse_name(parser: Parser):
         token = parser.tokens[parser.current]
         if token.ast_type in [TokenType.WHITE_SPACE, TokenType.TEXT]:
-            return Result(
-                1, Node(NodeType.TEXT, None, token.text, token.start, token.end)
-            )
+            return Result(1, Node(NodeType.TEXT, None, token.text, token.start, token.end))
         if token.ast_type in [
             TokenType.BEGIN_PARAMETER,
             TokenType.END_PARAMETER,
@@ -90,9 +85,7 @@ def parse_alternative_separator(parser: Parser) -> Result:
             if not self.looking_at(tokens, parser.current, TokenType.ALTERNATION):
                 return Result(0, None)
             token = tokens[parser.current]
-            return Result(
-                1, Node(NodeType.ALTERNATIVE, None, token.text, token.start, token.end)
-            )
+            return Result(1, Node(NodeType.ALTERNATIVE, None, token.text, token.start, token.end))
 
         alternative_parsers = [
             parse_alternative_separator,
@@ -130,11 +123,7 @@ def parse_alternation(parser: Parser) -> Result:
                 ],
             )
             sub_current = parser.current + consumed
-            if not [
-                _ast_node.ast_type
-                for _ast_node in ast_nodes
-                if _ast_node.ast_type == NodeType.ALTERNATIVE
-            ]:
+            if not [_ast_node.ast_type for _ast_node in ast_nodes if _ast_node.ast_type == NodeType.ALTERNATIVE]:
                 return Result(0, None)
 
             start = tokens[parser.current].start
@@ -204,9 +193,7 @@ def _parse_between(parser: Parser):
         return _parse_between
 
     @staticmethod
-    def parse_token(
-        expression, parsers: List, tokens: List[Token], start_at: int
-    ) -> Result:
+    def parse_token(expression, parsers: List, tokens: List[Token], start_at: int) -> Result:
         for parser in parsers:
             consumed, ast = parser(Parser(expression, tokens, start_at))
             if consumed:
@@ -237,12 +224,8 @@ def parse_tokens_until(
             ast.append(result.ast_node)
         return current - start_at, ast
 
-    def looking_at_any(
-        self, tokens: List[Token], position: int, token_types: List[TokenType]
-    ) -> bool:
-        return any(
-            self.looking_at(tokens, position, token_type) for token_type in token_types
-        )
+    def looking_at_any(self, tokens: List[Token], position: int, token_types: List[TokenType]) -> bool:
+        return any(self.looking_at(tokens, position, token_type) for token_type in token_types)
 
     @staticmethod
     def looking_at(tokens: List[Token], position: int, token_type: TokenType) -> bool:
@@ -254,9 +237,7 @@ def looking_at(tokens: List[Token], position: int, token_type: TokenType) -> boo
             return token_type == TokenType.END_OF_LINE
         return tokens[position].ast_type == token_type
 
-    def split_alternatives(
-        self, start: int, end: int, alternation: List[Node]
-    ) -> List[Node]:
+    def split_alternatives(self, start: int, end: int, alternation: List[Node]) -> List[Node]:
         separators = []
         alternatives = []
         alternative = []
@@ -271,9 +252,7 @@ def split_alternatives(
         return list(self.create_alternative_nodes(start, end, separators, alternatives))
 
     @staticmethod
-    def create_alternative_nodes(
-        start: int, end: int, separators: List, alternatives: List
-    ) -> List[Node]:
+    def create_alternative_nodes(start: int, end: int, separators: List, alternatives: List) -> List[Node]:
         for index, alternative in enumerate(alternatives):
             if index == 0:
                 right_separator = separators[index]
@@ -286,9 +265,7 @@ def create_alternative_nodes(
                 )
             elif index == len(alternatives) - 1:
                 left_separator = separators[index - 1]
-                yield Node(
-                    NodeType.ALTERNATIVE, alternative, None, left_separator.end, end
-                )
+                yield Node(NodeType.ALTERNATIVE, alternative, None, left_separator.end, end)
             else:
                 left_separator = separators[index - 1]
                 right_separator = separators[index]

python/cucumber_expressions/expression_tokenizer.py

@@ -92,9 +92,5 @@ def token_type_of(self, char: str, treat_as_text) -> TokenType:
         )
 
     @staticmethod
-    def should_create_new_token(
-        previous_token_type: TokenType, current_token_type: TokenType
-    ):
-        return current_token_type != previous_token_type or (
-            current_token_type not in [TokenType.WHITE_SPACE, TokenType.TEXT]
-        )
+    def should_create_new_token(previous_token_type: TokenType, current_token_type: TokenType):
+        return current_token_type != previous_token_type or (current_token_type not in [TokenType.WHITE_SPACE, TokenType.TEXT])