robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/parsing/model/statements.py

@@ -15,14 +15,16 @@
 
 import ast
 import re
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Iterator, Sequence
-from typing import cast, ClassVar, overload, TYPE_CHECKING, Type, TypeVar
+from typing import cast, ClassVar, Literal, overload, TYPE_CHECKING, Type, TypeVar
 
 from robot.conf import Language
 from robot.running.arguments import UserKeywordArgumentParser
 from robot.utils import normalize_whitespace, seq2str, split_from_equals, test_or_task
-from robot.variables import is_scalar_assign, is_dict_variable, search_variable
+from robot.variables import (contains_variable, is_scalar_assign, is_dict_variable,
+                             search_variable)
 
 from ..lexer import Token
 
@@ -45,10 +47,13 @@ class Node(ast.AST, ABC):
 
 
 class Statement(Node, ABC):
-    _fields = ('type', 'tokens')
+    _attributes = ('type', 'tokens') + Node._attributes
     type: str
     handles_types: 'ClassVar[tuple[str, ...]]' = ()
     statement_handlers: 'ClassVar[dict[str, Type[Statement]]]' = {}
+    # Accepted configuration options. If the value is a tuple, it lists accepted
+    # values. If the used value contains a variable, it cannot be validated.
+    options: 'dict[str, tuple|None]' = {}
 
     def __init__(self, tokens: 'Sequence[Token]', errors: 'Sequence[str]' = ()):
         self.tokens = tuple(tokens)
@@ -164,15 +169,10 @@ class Statement(Node, ABC):
 
         New in Robot Framework 6.1.
         """
-        options = self._get_options()
-        return ', '.join(options[name]) if name in options else default
+        return self._get_options().get(name, default)
 
-    def _get_options(self) -> 'dict[str, list[str]]':
-        options: 'dict[str, list[str]]' = {}
-        for option in self.get_values(Token.OPTION):
-            name, value = option.split('=', 1)
-            options.setdefault(name, []).append(value)
-        return options
+    def _get_options(self) -> 'dict[str, str]':
+        return dict(opt.split('=', 1) for opt in self.get_values(Token.OPTION))
 
     @property
     def lines(self) -> 'Iterator[list[Token]]':
@@ -189,10 +189,13 @@ class Statement(Node, ABC):
         pass
 
     def _validate_options(self):
-        for name, values in self._get_options().items():
-            if len(values) > 1:
-                self.errors += (f"Option '{name}' allowed only once, got values "
-                                f"{seq2str(values)}.",)
+        for name, value in self._get_options().items():
+            if self.options[name] is not None:
+                expected = self.options[name]
+                if value.upper() not in expected and not contains_variable(value):
+                    self.errors += (f"{self.type} option '{name}' does not accept "
+                                    f"value '{value}'. Valid values are "
+                                    f"{seq2str(expected)}.",)
 
     def __iter__(self) -> 'Iterator[Token]':
         return iter(self.tokens)
@@ -344,7 +347,7 @@ class LibraryImport(Statement):
                            Token(Token.ARGUMENT, arg)])
         if alias is not None:
             tokens.extend([Token(Token.SEPARATOR, separator),
-                           Token(Token.WITH_NAME),
+                           Token(Token.AS),
                            Token(Token.SEPARATOR, separator),
                            Token(Token.NAME, alias)])
         tokens.append(Token(Token.EOL, eol))
@@ -360,7 +363,7 @@ class LibraryImport(Statement):
 
     @property
     def alias(self) -> 'str|None':
-        separator = self.get_token(Token.WITH_NAME)
+        separator = self.get_token(Token.AS)
         return self.get_tokens(Token.NAME)[-1].value if separator else None
 
 
@@ -467,13 +470,13 @@ class Metadata(DocumentationOrMetadata):
 
 
 @Statement.register
-class ForceTags(MultiValue):
-    type = Token.FORCE_TAGS
+class TestTags(MultiValue):
+    type = Token.TEST_TAGS
 
     @classmethod
     def from_params(cls, values: 'Sequence[str]', separator: str = FOUR_SPACES,
-                    eol: str = EOL) -> 'ForceTags':
-        tokens = [Token(Token.FORCE_TAGS, 'Force Tags')]
+                    eol: str = EOL) -> 'TestTags':
+        tokens = [Token(Token.TEST_TAGS, 'Test Tags')]
         for tag in values:
             tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.ARGUMENT, tag)])
@@ -627,15 +630,24 @@ class TestTimeout(SingleValue):
 @Statement.register
 class Variable(Statement):
     type = Token.VARIABLE
+    options = {
+        'separator': None
+    }
 
     @classmethod
-    def from_params(cls, name: str, value: 'str|Sequence[str]',
-                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'Variable':
+    def from_params(cls, name: str,
+                    value: 'str|Sequence[str]',
+                    value_separator: 'str|None' = None,
+                    separator: str = FOUR_SPACES,
+                    eol: str = EOL) -> 'Variable':
         values = [value] if isinstance(value, str) else value
         tokens = [Token(Token.VARIABLE, name)]
         for value in values:
             tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.ARGUMENT, value)])
+        if value_separator is not None:
+            tokens.extend([Token(Token.SEPARATOR, separator),
+                           Token(Token.OPTION, f'separator={value_separator}')])
         tokens.append(Token(Token.EOL, eol))
         return cls(tokens)
 
@@ -650,26 +662,13 @@ class Variable(Statement):
     def value(self) -> 'tuple[str, ...]':
         return self.get_values(Token.ARGUMENT)
 
-    def validate(self, ctx: 'ValidationContext'):
-        name = self.get_value(Token.VARIABLE)
-        match = search_variable(name, ignore_errors=True)
-        if not match.is_assign(allow_assign_mark=True, allow_nested=True):
-            self.errors += (f"Invalid variable name '{name}'.",)
-        if match.is_dict_assign(allow_assign_mark=True):
-            self._validate_dict_items()
-
-    def _validate_dict_items(self):
-        for item in self.get_values(Token.ARGUMENT):
-            if not self._is_valid_dict_item(item):
-                self.errors += (
-                    f"Invalid dictionary variable item '{item}'. "
-                    f"Items must use 'name=value' syntax or be dictionary "
-                    f"variables themselves.",
-                )
+    @property
+    def separator(self) -> 'str|None':
+        return self.get_option('separator')
 
-    def _is_valid_dict_item(self, item: str) -> bool:
-        name, value = split_from_equals(item)
-        return value is not None or is_dict_variable(item)
+    def validate(self, ctx: 'ValidationContext'):
+        VariableValidator().validate(self)
+        self._validate_options()
 
 
 @Statement.register
@@ -819,28 +818,18 @@ class Arguments(MultiValue):
         self.errors = tuple(errors)
 
 
-# TODO: Change Return to mean ReturnStatement in RF 7.0
-# - Rename current Return to ReturnSetting
-# - Rename current ReturnStatement to Return
-# - Add backwards compatible ReturnStatement alias
-# - Change Token.RETURN to mean Token.RETURN_STATEMENT
-# - Update also ModelVisitor
 @Statement.register
-class Return(MultiValue):
+class ReturnSetting(MultiValue):
     """Represents the deprecated ``[Return]`` setting.
 
-    In addition to the ``[Return]`` setting itself, also the ``Return`` node
-    in the parsing model is deprecated and :class:`ReturnSetting` (new in
-    Robot Framework 6.1) should be used instead. :class:`ReturnStatement` will
-    be renamed to ``Return`` in Robot Framework 7.0.
-
-    Eventually ``[Return]`` and ``ReturnSetting`` will be removed altogether.
+    This class was named ``Return`` prior to Robot Framework 7.0. A forward
+    compatible ``ReturnSetting`` alias existed already in Robot Framework 6.1.
     """
     type = Token.RETURN
 
     @classmethod
     def from_params(cls, args: 'Sequence[str]', indent: str = FOUR_SPACES,
-                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'Return':
+                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'ReturnSetting':
         tokens = [Token(Token.SEPARATOR, indent),
                   Token(Token.RETURN, '[Return]')]
         for arg in args:
@@ -850,10 +839,6 @@ class Return(MultiValue):
         return cls(tokens)
 
 
-# Forward compatible alias for Return.
-ReturnSetting = Return
-
-
 @Statement.register
 class KeywordCall(Statement):
     type = Token.KEYWORD
@@ -908,15 +893,23 @@ class TemplateArguments(Statement):
 @Statement.register
 class ForHeader(Statement):
     type = Token.FOR
+    options = {
+        'start': None,
+        'mode': ('STRICT', 'SHORTEST', 'LONGEST'),
+        'fill': None
+    }
 
     @classmethod
-    def from_params(cls, variables: 'Sequence[str]', values: 'Sequence[str]',
-                    flavor: str = 'IN', indent: str = FOUR_SPACES,
-                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'ForHeader':
+    def from_params(cls, assign: 'Sequence[str]',
+                    values: 'Sequence[str]',
+                    flavor: Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP'] = 'IN',
+                    indent: str = FOUR_SPACES,
+                    separator: str = FOUR_SPACES,
+                    eol: str = EOL) -> 'ForHeader':
         tokens = [Token(Token.SEPARATOR, indent),
                   Token(Token.FOR),
                   Token(Token.SEPARATOR, separator)]
-        for variable in variables:
+        for variable in assign:
             tokens.extend([Token(Token.VARIABLE, variable),
                            Token(Token.SEPARATOR, separator)])
         tokens.append(Token(Token.FOR_SEPARATOR, flavor))
@@ -927,9 +920,15 @@ class ForHeader(Statement):
         return cls(tokens)
 
     @property
-    def variables(self) -> 'tuple[str, ...]':
+    def assign(self) -> 'tuple[str, ...]':
         return self.get_values(Token.VARIABLE)
 
+    @property
+    def variables(self) -> 'tuple[str, ...]':    # TODO: Remove in RF 8.0.
+        warnings.warn("'ForHeader.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'ForHeader.assign' instead.")
+        return self.assign
+
     @property
     def values(self) -> 'tuple[str, ...]':
         return self.get_values(Token.ARGUMENT)
@@ -952,17 +951,17 @@ class ForHeader(Statement):
         return self.get_option('fill') if self.flavor == 'IN ZIP' else None
 
     def validate(self, ctx: 'ValidationContext'):
-        self._validate_options()
-        if not self.variables:
+        if not self.assign:
             self._add_error('no loop variables')
         if not self.flavor:
             self._add_error("no 'IN' or other valid separator")
         else:
-            for var in self.variables:
+            for var in self.assign:
                 if not is_scalar_assign(var):
                     self._add_error(f"invalid loop variable '{var}'")
             if not self.values:
                 self._add_error('no loop values')
+        self._validate_options()
 
     def _add_error(self, error: str):
         self.errors += (f'FOR loop has {error}.',)
@@ -1084,10 +1083,13 @@ class TryHeader(NoArgumentHeader):
 @Statement.register
 class ExceptHeader(Statement):
     type = Token.EXCEPT
+    options = {
+        'type': ('GLOB', 'REGEXP', 'START', 'LITERAL')
+    }
 
     @classmethod
     def from_params(cls, patterns: 'Sequence[str]' = (), type: 'str|None' = None,
-                    variable: 'str|None' = None, indent: str = FOUR_SPACES,
+                    assign: 'str|None' = None, indent: str = FOUR_SPACES,
                     separator: str = FOUR_SPACES, eol: str = EOL) -> 'ExceptHeader':
         tokens = [Token(Token.SEPARATOR, indent),
                   Token(Token.EXCEPT)]
@@ -1097,11 +1099,11 @@ class ExceptHeader(Statement):
         if type:
             tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.OPTION, f'type={type}')])
-        if variable:
+        if assign:
             tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.AS),
                            Token(Token.SEPARATOR, separator),
-                           Token(Token.VARIABLE, variable)])
+                           Token(Token.VARIABLE, assign)])
         tokens.append(Token(Token.EOL, eol))
         return cls(tokens)
 
@@ -1114,20 +1116,26 @@ class ExceptHeader(Statement):
         return self.get_option('type')
 
     @property
-    def variable(self) -> 'str|None':
+    def assign(self) -> 'str|None':
         return self.get_value(Token.VARIABLE)
 
+    @property
+    def variable(self) -> 'str|None':    # TODO: Remove in RF 8.0.
+        warnings.warn("'ExceptHeader.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'ExceptHeader.assigns' instead.")
+        return self.assign
+
     def validate(self, ctx: 'ValidationContext'):
-        self._validate_options()
         as_token = self.get_token(Token.AS)
         if as_token:
-            variables = self.get_tokens(Token.VARIABLE)
-            if not variables:
-                self.errors += ("EXCEPT's AS requires variable.",)
-            elif len(variables) > 1:
-                self.errors += ("EXCEPT's AS accepts only one variable.",)
-            elif not is_scalar_assign(variables[0].value):
-                self.errors += (f"EXCEPT's AS variable '{variables[0].value}' is invalid.",)
+            assign = self.get_tokens(Token.VARIABLE)
+            if not assign:
+                self.errors += ("EXCEPT AS requires a value.",)
+            elif len(assign) > 1:
+                self.errors += ("EXCEPT AS accepts only one value.",)
+            elif not is_scalar_assign(assign[0].value):
+                self.errors += (f"EXCEPT AS variable '{assign[0].value}' is invalid.",)
+        self._validate_options()
 
 
 @Statement.register
@@ -1143,6 +1151,11 @@ class End(NoArgumentHeader):
 @Statement.register
 class WhileHeader(Statement):
     type = Token.WHILE
+    options = {
+        'limit': None,
+        'on_limit': ('PASS', 'FAIL'),
+        'on_limit_message': None
+    }
 
     @classmethod
     def from_params(cls, condition: str, limit: 'str|None' = None,
@@ -1154,13 +1167,13 @@ class WhileHeader(Statement):
                   Token(Token.SEPARATOR, separator),
                   Token(Token.ARGUMENT, condition)]
         if limit:
-            tokens.extend([Token(Token.SEPARATOR, indent),
+            tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.OPTION, f'limit={limit}')])
         if on_limit:
-            tokens.extend([Token(Token.SEPARATOR, indent),
+            tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.OPTION, f'on_limit={on_limit}')])
         if on_limit_message:
-            tokens.extend([Token(Token.SEPARATOR, indent),
+            tokens.extend([Token(Token.SEPARATOR, separator),
                            Token(Token.OPTION, f'on_limit_message={on_limit_message}')])
         tokens.append(Token(Token.EOL, eol))
         return cls(tokens)
@@ -1182,29 +1195,84 @@ class WhileHeader(Statement):
         return self.get_option('on_limit_message')
 
     def validate(self, ctx: 'ValidationContext'):
-        conditions = self.get_tokens(Token.ARGUMENT)
+        conditions = self.get_values(Token.ARGUMENT)
         if len(conditions) > 1:
-            self._add_error(f'cannot have more than one condition, got '
-                            f'{seq2str(c.value for c in conditions)}')
+            self.errors += (f"WHILE accepts only one condition, got {len(conditions)} "
+                            f"conditions {seq2str(conditions)}.",)
         if self.on_limit and not self.limit:
-            self._add_error("'on_limit' option cannot be used without 'limit'")
+            self.errors += ("WHILE option 'on_limit' cannot be used without 'limit'.",)
         self._validate_options()
 
-    def _add_error(self, error: str):
-        self.errors += (f'WHILE loop {error}.',)
-
 
 @Statement.register
-class ReturnStatement(Statement):
-    type = Token.RETURN_STATEMENT
+class Var(Statement):
+    type = Token.VAR
+    options = {
+        'scope': ('GLOBAL', 'SUITE', 'TEST', 'TASK', 'LOCAL'),
+        'separator': None
+    }
+
+    @classmethod
+    def from_params(cls, name: str,
+                    value: 'str|Sequence[str]',
+                    scope: 'str|None' = None,
+                    value_separator: 'str|None' = None,
+                    indent: str = FOUR_SPACES,
+                    separator: str = FOUR_SPACES,
+                    eol: str = EOL) -> 'Var':
+        tokens = [Token(Token.SEPARATOR, indent),
+                  Token(Token.VAR),
+                  Token(Token.SEPARATOR, separator),
+                  Token(Token.VARIABLE, name)]
+        values = [value] if isinstance(value, str) else value
+        for value in values:
+            tokens.extend([Token(Token.SEPARATOR, separator),
+                           Token(Token.ARGUMENT, value)])
+        if scope:
+            tokens.extend([Token(Token.SEPARATOR, separator),
+                           Token(Token.OPTION, f'scope={scope}')])
+        if value_separator:
+            tokens.extend([Token(Token.SEPARATOR, separator),
+                           Token(Token.OPTION, f'separator={value_separator}')])
+        tokens.append(Token(Token.EOL, eol))
+        return cls(tokens)
+
+    @property
+    def name(self) -> str:
+        name = self.get_value(Token.VARIABLE, '')
+        if name.endswith('='):
+            return name[:-1].rstrip()
+        return name
 
     @property
-    def values(self):
+    def value(self) -> 'tuple[str, ...]':
         return self.get_values(Token.ARGUMENT)
 
+    @property
+    def scope(self) -> 'str|None':
+        return self.get_option('scope')
+
+    @property
+    def separator(self) -> 'str|None':
+        return self.get_option('separator')
+
+    def validate(self, ctx: 'ValidationContext'):
+        VariableValidator().validate(self)
+        self._validate_options()
+
+
+@Statement.register
+class Return(Statement):
+    """Represents the RETURN statement.
+
+    This class named ``ReturnStatement`` prior to Robot Framework 7.0.
+    The old name still exists as a backwards compatible alias.
+    """
+    type = Token.RETURN_STATEMENT
+
     @classmethod
     def from_params(cls, values: 'Sequence[str]' = (), indent: str = FOUR_SPACES,
-                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'ReturnStatement':
+                    separator: str = FOUR_SPACES, eol: str = EOL) -> 'Return':
         tokens = [Token(Token.SEPARATOR, indent),
                   Token(Token.RETURN_STATEMENT)]
         for value in values:
@@ -1213,6 +1281,10 @@ class ReturnStatement(Statement):
         tokens.append(Token(Token.EOL, eol))
         return cls(tokens)
 
+    @property
+    def values(self) -> 'tuple[str, ...]':
+        return self.get_values(Token.ARGUMENT)
+
     def validate(self, ctx: 'ValidationContext'):
         if not ctx.in_keyword:
             self.errors += ('RETURN can only be used inside a user keyword.',)
@@ -1220,6 +1292,10 @@ class ReturnStatement(Statement):
             self.errors += ('RETURN cannot be used in FINALLY branch.',)
 
 
+# Backwards compatibility with RF < 7.
+ReturnStatement = Return
+
+
 class LoopControl(NoArgumentHeader, ABC):
 
     def validate(self, ctx: 'ValidationContext'):
@@ -1310,3 +1386,26 @@ class EmptyLine(Statement):
     @classmethod
     def from_params(cls, eol: str = EOL):
         return cls([Token(Token.EOL, eol)])
+
+
+class VariableValidator:
+
+    def validate(self, statement: Statement):
+        name = statement.get_value(Token.VARIABLE, '')
+        match = search_variable(name, ignore_errors=True)
+        if not match.is_assign(allow_assign_mark=True, allow_nested=True):
+            statement.errors += (f"Invalid variable name '{name}'.",)
+        if match.identifier == '&':
+            self._validate_dict_items(statement)
+
+    def _validate_dict_items(self, statement: Statement):
+        for item in statement.get_values(Token.ARGUMENT):
+            if not self._is_valid_dict_item(item):
+                statement.errors += (
+                    f"Invalid dictionary variable item '{item}'. Items must use "
+                    f"'name=value' syntax or be dictionary variables themselves.",
+                )
+
+    def _is_valid_dict_item(self, item: str) -> bool:
+        name, value = split_from_equals(item)
+        return value is not None or is_dict_variable(item)

robotframework-7.0/src/robot/parsing/model/visitor.py

@@ -0,0 +1,100 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from ast import NodeTransformer, NodeVisitor
+from typing import Callable
+
+from .statements import Node
+
+
+# Unbound method and thus needs `NodeVisitor` as `self`.
+VisitorMethod = Callable[[NodeVisitor, Node], 'None|Node|list[Node]']
+
+
+class VisitorFinder:
+    __visitor_cache: 'dict[type[Node], VisitorMethod]'
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.__visitor_cache = {}
+
+    @classmethod
+    def _find_visitor(cls, node_cls: 'type[Node]') -> VisitorMethod:
+        if node_cls not in cls.__visitor_cache:
+            visitor = cls._find_visitor_from_class(node_cls)
+            cls.__visitor_cache[node_cls] = visitor or cls.generic_visit
+        return cls.__visitor_cache[node_cls]
+
+    @classmethod
+    def _find_visitor_from_class(cls, node_cls: 'type[Node]') -> 'VisitorMethod|None':
+        method_name = 'visit_' + node_cls.__name__
+        method = getattr(cls, method_name, None)
+        if callable(method):
+            return method
+        if method_name in ('visit_TestTags', 'visit_Return'):
+            method = cls._backwards_compatibility(method_name)
+            if callable(method):
+                return method
+        for base in node_cls.__bases__:
+            if issubclass(base, Node):
+                method = cls._find_visitor_from_class(base)
+                if method:
+                    return method
+        return None
+
+    @classmethod
+    def _backwards_compatibility(cls, method_name):
+        name = {'visit_TestTags': 'visit_ForceTags',
+                'visit_Return': 'visit_ReturnStatement'}[method_name]
+        return getattr(cls, name, None)
+
+    def generic_visit(self, node: Node) -> 'None|Node|list[Node]':
+        raise NotImplementedError
+
+
+class ModelVisitor(NodeVisitor, VisitorFinder):
+    """NodeVisitor that supports matching nodes based on their base classes.
+
+    The biggest difference compared to the standard `ast.NodeVisitor
+    <https://docs.python.org/library/ast.html#ast.NodeVisitor>`__,
+    is that this class allows creating ``visit_ClassName`` methods so that
+    the ``ClassName`` is one of the base classes of the node. For example,
+    the following visitor method matches all node classes that extend
+    ``Statement``::
+
+        def visit_Statement(self, node):
+            ...
+
+    Another difference is that visitor methods are cached for performance
+    reasons. This means that dynamically adding ``visit_Something`` methods
+    does not work.
+    """
+
+    def visit(self, node: Node) -> None:
+        visitor_method = self._find_visitor(type(node))
+        visitor_method(self, node)
+
+
+class ModelTransformer(NodeTransformer, VisitorFinder):
+    """NodeTransformer that supports matching nodes based on their base classes.
+
+    See :class:`ModelVisitor` for explanation how this is different compared
+    to the standard `ast.NodeTransformer
+    <https://docs.python.org/library/ast.html#ast.NodeTransformer>`__.
+    """
+
+    def visit(self, node: Node) -> 'None|Node|list[Node]':
+        visitor_method = self._find_visitor(type(node))
+        return visitor_method(self, node)

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/rebot.py

@@ -130,6 +130,8 @@ Options
                           specified. Given path, similarly as paths given to
                           --log, --report and --xunit, is relative to
                           --outputdir unless given as an absolute path.
+    --legacyoutput        Create XML output file in format compatible with
+                          Robot Framework 6.x and earlier.
  -l --log file            HTML log file. Can be disabled by giving a special
                           name `NONE`. Default: log.html
                           Examples: `--log mylog.html`, `-l none`

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/reporting/expandkeywordmatcher.py

@@ -33,6 +33,6 @@ class ExpandKeywordMatcher:
         self._match_tags = MultiMatcher(tags).match_any
 
     def match(self, kw: Keyword):
-        if (self._match_name(kw.name or '')
+        if (self._match_name(kw.full_name or '')
                 or self._match_tags(kw.tags)) and not kw.not_run:
             self.matched_ids.append(kw.id)

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/reporting/jsbuildingcontext.py

@@ -13,12 +13,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import datetime
 from contextlib import contextmanager
 from pathlib import Path
 
 from robot.output.loggerhelper import LEVELS
-from robot.utils import (attribute_escape, get_link_path, html_escape, safe_str,
-                         timestamp_to_secs)
+from robot.utils import attribute_escape, get_link_path, html_escape, safe_str
 
 from .expandkeywordmatcher import ExpandKeywordMatcher
 from .stringcache import StringCache
@@ -48,7 +48,9 @@ class JsBuildingContext:
         return None
 
     def string(self, string, escape=True, attr=False):
-        if escape and string:
+        if not string:
+            return self._strings.empty
+        if escape:
             if not isinstance(string, str):
                 string = safe_str(string)
             string = (html_escape if not attr else attribute_escape)(string)
@@ -64,10 +66,10 @@ class JsBuildingContext:
             if self._log_dir and source and source.exists() else ''
         return self.string(rel_source)
 
-    def timestamp(self, time):
-        if not time:
+    def timestamp(self, ts: datetime) -> 'int|None':
+        if not ts:
             return None
-        millis = int(timestamp_to_secs(time) * 1000)
+        millis = round(ts.timestamp() * 1000)
         if self.basemillis is None:
             self.basemillis = millis
         return millis - self.basemillis