robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/blocklexers.py

@@ -29,8 +29,9 @@ from .statementlexers import (BreakLexer, CommentLexer, CommentSectionHeaderLexe
                               KeywordSettingLexer, Lexer, ReturnLexer, SettingLexer,
                               SettingSectionHeaderLexer, SyntaxErrorLexer,
                               TaskSectionHeaderLexer, TestCaseSectionHeaderLexer,
-                              TestCaseSettingLexer, TryHeaderLexer, VariableLexer,
-                              VariableSectionHeaderLexer, WhileHeaderLexer)
+                              TestCaseSettingLexer, TryHeaderLexer, VarLexer,
+                              VariableLexer, VariableSectionHeaderLexer,
+                              WhileHeaderLexer)
 from .tokens import StatementTokens, Token
 
 
@@ -200,8 +201,8 @@ class TestCaseLexer(TestOrKeywordLexer):
         self._lex_with_priority(priority=TestCaseSettingLexer)
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
-        return (TestCaseSettingLexer, ForLexer, InlineIfLexer, IfLexer,
-                TryLexer, WhileLexer, SyntaxErrorLexer, KeywordCallLexer)
+        return (TestCaseSettingLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer,
+                WhileLexer, VarLexer, SyntaxErrorLexer, KeywordCallLexer)
 
 
 class KeywordLexer(TestOrKeywordLexer):
@@ -211,8 +212,8 @@ class KeywordLexer(TestOrKeywordLexer):
         super().__init__(ctx.keyword_context())
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
-        return (KeywordSettingLexer, ForLexer, InlineIfLexer, IfLexer, ReturnLexer,
-                TryLexer, WhileLexer, SyntaxErrorLexer, KeywordCallLexer)
+        return (KeywordSettingLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer,
+                WhileLexer, VarLexer, ReturnLexer, SyntaxErrorLexer, KeywordCallLexer)
 
 
 class NestedBlockLexer(BlockLexer, ABC):
@@ -242,7 +243,8 @@ class ForLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (ForHeaderLexer, InlineIfLexer, IfLexer, TryLexer, WhileLexer, EndLexer,
-                ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer, KeywordCallLexer)
+                VarLexer, ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
+                KeywordCallLexer)
 
 
 class WhileLexer(NestedBlockLexer):
@@ -252,7 +254,8 @@ class WhileLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (WhileHeaderLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer, EndLexer,
-                ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer, KeywordCallLexer)
+                VarLexer, ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
+                KeywordCallLexer)
 
 
 class TryLexer(NestedBlockLexer):
@@ -262,8 +265,9 @@ class TryLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (TryHeaderLexer, ExceptHeaderLexer, ElseHeaderLexer, FinallyHeaderLexer,
-                ForLexer, InlineIfLexer, IfLexer, WhileLexer, EndLexer, ReturnLexer,
-                BreakLexer, ContinueLexer, SyntaxErrorLexer, KeywordCallLexer)
+                ForLexer, InlineIfLexer, IfLexer, WhileLexer, EndLexer, VarLexer,
+                ReturnLexer, BreakLexer, ContinueLexer, SyntaxErrorLexer,
+                KeywordCallLexer)
 
 
 class IfLexer(NestedBlockLexer):
@@ -273,8 +277,8 @@ class IfLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (InlineIfLexer, IfHeaderLexer, ElseIfHeaderLexer, ElseHeaderLexer,
-                ForLexer, TryLexer, WhileLexer, EndLexer, ReturnLexer, ContinueLexer,
-                BreakLexer, SyntaxErrorLexer, KeywordCallLexer)
+                ForLexer, TryLexer, WhileLexer, EndLexer, VarLexer, ReturnLexer,
+                ContinueLexer, BreakLexer, SyntaxErrorLexer, KeywordCallLexer)
 
 
 class InlineIfLexer(NestedBlockLexer):
@@ -288,7 +292,7 @@ class InlineIfLexer(NestedBlockLexer):
         return False
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
-        return (InlineIfHeaderLexer, ElseIfHeaderLexer, ElseHeaderLexer,
+        return (InlineIfHeaderLexer, ElseIfHeaderLexer, ElseHeaderLexer, VarLexer,
                 ReturnLexer, ContinueLexer, BreakLexer, KeywordCallLexer)
 
     def input(self, statement: StatementTokens):

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/context.py

@@ -76,8 +76,18 @@ class FileContext(LexingContext):
 
     def _handles_section(self, statement: StatementTokens, header: str) -> bool:
         marker = statement[0].value
-        return bool(marker and marker[0] == '*' and
-                    self.languages.headers.get(self._normalize(marker)) == header)
+        if not marker or marker[0] != '*':
+            return False
+        normalized = self._normalize(marker)
+        if self.languages.headers.get(normalized) == header:
+            return True
+        if normalized == header[:-1]:
+            statement[0].error = (
+                f"Singular section headers like '{marker}' are deprecated. "
+                f"Use plural format like '*** {header} ***' instead."
+            )
+            return True
+        return False
 
     def _normalize(self, marker: str) -> str:
         return normalize_whitespace(marker).strip('* ').title()

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/lexer.py

@@ -128,7 +128,7 @@ class Lexer:
 
     def _get_tokens(self, statements: 'Iterable[list[Token]]') -> 'Iterator[Token]':
         if self.data_only:
-            ignored_types = {None, Token.COMMENT_HEADER, Token.COMMENT}
+            ignored_types = {None, Token.COMMENT}
         else:
             ignored_types = {None}
         inline_if_type = Token.INLINE_IF

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/settings.py

@@ -112,8 +112,7 @@ class Settings(ABC):
             token.type = Token.COMMENT
 
     def _lex_setting(self, statement: StatementTokens, name: str):
-        # TODO: Change token type from 'FORCE TAGS' to 'TEST TAGS' in RF 7.0.
-        statement[0].type = {'Test Tags': Token.FORCE_TAGS,
+        statement[0].type = {'Test Tags': Token.TEST_TAGS,
                              'Name': Token.SUITE_NAME}.get(name, name.upper())
         self.settings[name] = values = statement[1:]
         if name in self.name_and_arguments:
@@ -122,6 +121,9 @@ class Settings(ABC):
             self._lex_name_arguments_and_with_name(values)
         else:
             self._lex_arguments(values)
+        if name == 'Return':
+            statement[0].error = ("The '[Return]' setting is deprecated. "
+                                  "Use the 'RETURN' statement instead.")
 
     def _lex_name_and_arguments(self, tokens: StatementTokens):
         if tokens:
@@ -132,7 +134,7 @@ class Settings(ABC):
         self._lex_name_and_arguments(tokens)
         if len(tokens) > 1 and \
                 normalize_whitespace(tokens[-2].value) in ('WITH NAME', 'AS'):
-            tokens[-2].type = Token.WITH_NAME
+            tokens[-2].type = Token.AS
             tokens[-1].type = Token.NAME
 
     def _lex_arguments(self, tokens: StatementTokens):
@@ -257,6 +259,7 @@ class KeywordSettings(Settings):
     names = (
         'Documentation',
         'Arguments',
+        'Setup',
         'Teardown',
         'Timeout',
         'Tags',

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/statementlexers.py

@@ -14,7 +14,6 @@
 #  limitations under the License.
 
 from abc import ABC, abstractmethod
-from typing import List
 
 from robot.errors import DataError
 from robot.utils import normalize_whitespace
@@ -58,14 +57,20 @@ class StatementLexer(Lexer, ABC):
     def input(self, statement: StatementTokens):
         self.statement = statement
 
+    @abstractmethod
     def lex(self):
         raise NotImplementedError
 
     def _lex_options(self, *names: str, end_index: 'int|None' = None):
+        seen = set()
         for token in reversed(self.statement[:end_index]):
-            if not token.value.startswith(names):
-                break
-            token.type = Token.OPTION
+            if '=' in token.value:
+                name = token.value.split('=')[0]
+                if name in names and name not in seen:
+                    token.type = Token.OPTION
+                    seen.add(name)
+                    continue
+            break
 
 
 class SingleType(StatementLexer, ABC):
@@ -181,6 +186,11 @@ class VariableLexer(TypeAndArguments):
     ctx: FileContext
     token_type = Token.VARIABLE
 
+    def lex(self):
+        super().lex()
+        if self.statement[0].value[:1] == '$':
+            self._lex_options('separator')
+
 
 class KeywordCallLexer(StatementLexer):
     ctx: 'TestCaseContext|KeywordContext'
@@ -200,7 +210,8 @@ class KeywordCallLexer(StatementLexer):
         for token in self.statement:
             if keyword_seen:
                 token.type = Token.ARGUMENT
-            elif is_assign(token.value, allow_assign_mark=True, allow_items=True):
+            elif is_assign(token.value, allow_assign_mark=True, allow_nested=True,
+                           allow_items=True):
                 token.type = Token.ASSIGN
             else:
                 token.type = Token.KEYWORD
@@ -225,9 +236,9 @@ class ForHeaderLexer(StatementLexer):
             else:
                 token.type = Token.VARIABLE
         if separator == 'IN ENUMERATE':
-            self._lex_options('start=')
+            self._lex_options('start')
         elif separator == 'IN ZIP':
-            self._lex_options('mode=', 'fill=')
+            self._lex_options('mode', 'fill')
 
 
 class IfHeaderLexer(TypeAndArguments):
@@ -244,7 +255,8 @@ class InlineIfHeaderLexer(StatementLexer):
         for token in statement:
             if token.value == 'IF':
                 return True
-            if not is_assign(token.value, allow_assign_mark=True, allow_items=True):
+            if not is_assign(token.value, allow_assign_mark=True, allow_nested=True,
+                             allow_items=True):
                 return False
         return False
 
@@ -298,7 +310,7 @@ class ExceptHeaderLexer(StatementLexer):
                 token.type = Token.VARIABLE
             else:
                 token.type = Token.ARGUMENT
-        self._lex_options('type=', end_index=as_index)
+        self._lex_options('type', end_index=as_index)
 
 
 class FinallyHeaderLexer(TypeAndArguments):
@@ -318,7 +330,7 @@ class WhileHeaderLexer(StatementLexer):
         self.statement[0].type = Token.WHILE
         for token in self.statement[1:]:
             token.type = Token.ARGUMENT
-        self._lex_options('limit=', 'on_limit=', 'on_limit_message=')
+        self._lex_options('limit', 'on_limit', 'on_limit_message')
 
 
 class EndLexer(TypeAndArguments):
@@ -328,6 +340,23 @@ class EndLexer(TypeAndArguments):
         return statement[0].value == 'END'
 
 
+class VarLexer(StatementLexer):
+    token_type = Token.VAR
+
+    def handles(self, statement: StatementTokens) -> bool:
+        return statement[0].value == 'VAR'
+
+    def lex(self):
+        self.statement[0].type = Token.VAR
+        if len(self.statement) > 1:
+            name, *values = self.statement[1:]
+            name.type = Token.VARIABLE
+            for value in values:
+                value.type = Token.ARGUMENT
+            options = ['scope', 'separator'] if name.value[:1] == '$' else ['scope']
+            self._lex_options(*options)
+
+
 class ReturnLexer(TypeAndArguments):
     token_type = Token.RETURN_STATEMENT
 

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/lexer/tokens.py

@@ -16,7 +16,7 @@
 from collections.abc import Iterator
 from typing import cast, List
 
-from robot.variables import VariableIterator
+from robot.variables import VariableMatches
 
 
 # Type alias to ease typing elsewhere
@@ -49,7 +49,7 @@ class Token:
     KEYWORD_HEADER = 'KEYWORD HEADER'
     COMMENT_HEADER = 'COMMENT HEADER'
     INVALID_HEADER = 'INVALID HEADER'
-    FATAL_INVALID_HEADER = 'FATAL INVALID HEADER'
+    FATAL_INVALID_HEADER = 'FATAL INVALID HEADER'    # TODO: Remove in RF 8.
 
     TESTCASE_NAME = 'TESTCASE NAME'
     KEYWORD_NAME = 'KEYWORD NAME'
@@ -62,7 +62,8 @@ class Token:
     TEST_TEARDOWN = 'TEST TEARDOWN'
     TEST_TEMPLATE = 'TEST TEMPLATE'
     TEST_TIMEOUT = 'TEST TIMEOUT'
-    FORCE_TAGS = 'FORCE TAGS'
+    TEST_TAGS = 'TEST TAGS'
+    FORCE_TAGS = TEST_TAGS    # TODO: Remove in RF 8.
     DEFAULT_TAGS = 'DEFAULT TAGS'
     KEYWORD_TAGS = 'KEYWORD TAGS'
     LIBRARY = 'LIBRARY'
@@ -74,14 +75,11 @@ class Token:
     TIMEOUT = 'TIMEOUT'
     TAGS = 'TAGS'
     ARGUMENTS = 'ARGUMENTS'
-    # Use ´RETURN_SETTING` type instead of `RETURN`. `[Return]` is deprecated and
-    # `RETURN` type will be used with `RETURN` statement in the future.
-    RETURN = 'RETURN'
-    RETURN_SETTING = RETURN
+    RETURN = 'RETURN'          # TODO: Change to mean RETURN statement in RF 8.
+    RETURN_SETTING = RETURN    # TODO: Remove in RF 8.
 
-    # TODO: Change WITH_NAME value to AS in RF 7.0. Remove WITH_NAME in RF 8.
-    WITH_NAME = 'WITH NAME'
     AS = 'AS'
+    WITH_NAME = AS             # TODO: Remove in RF 8.
 
     NAME = 'NAME'
     VARIABLE = 'VARIABLE'
@@ -99,6 +97,7 @@ class Token:
     EXCEPT = 'EXCEPT'
     FINALLY = 'FINALLY'
     WHILE = 'WHILE'
+    VAR = 'VAR'
     RETURN_STATEMENT = 'RETURN STATEMENT'
     CONTINUE = 'CONTINUE'
     BREAK = 'BREAK'
@@ -110,10 +109,8 @@ class Token:
     CONFIG = 'CONFIG'
     EOL = 'EOL'
     EOS = 'EOS'
-
     ERROR = 'ERROR'
-    # TODO: FATAL_ERROR is no longer used, remove in RF 7.0
-    FATAL_ERROR = 'FATAL ERROR'
+    FATAL_ERROR = 'FATAL ERROR'    # TODO: Remove in RF 8.
 
     NON_DATA_TOKENS = frozenset((
         SEPARATOR,
@@ -132,7 +129,7 @@ class Token:
         TEST_TEARDOWN,
         TEST_TEMPLATE,
         TEST_TIMEOUT,
-        FORCE_TAGS,
+        TEST_TAGS,
         DEFAULT_TAGS,
         KEYWORD_TAGS,
         LIBRARY,
@@ -172,9 +169,10 @@ class Token:
                 Token.IF: 'IF', Token.INLINE_IF: 'IF', Token.ELSE_IF: 'ELSE IF',
                 Token.ELSE: 'ELSE', Token.FOR: 'FOR', Token.WHILE: 'WHILE',
                 Token.TRY: 'TRY', Token.EXCEPT: 'EXCEPT', Token.FINALLY: 'FINALLY',
-                Token.END: 'END', Token.CONTINUE: 'CONTINUE', Token.BREAK: 'BREAK',
-                Token.RETURN_STATEMENT: 'RETURN', Token.CONTINUATION: '...',
-                Token.EOL: '\n', Token.WITH_NAME: 'WITH NAME', Token.AS: 'AS'
+                Token.END: 'END', Token.VAR: 'VAR', Token.CONTINUE: 'CONTINUE',
+                Token.BREAK: 'BREAK', Token.RETURN_STATEMENT: 'RETURN',
+                Token.CONTINUATION: '...', Token.EOL: '\n', Token.WITH_NAME: 'AS',
+                Token.AS: 'AS'
             }.get(type, '')    # type: ignore
         self.value = cast(str, value)
         self.lineno = lineno
@@ -205,26 +203,26 @@ class Token:
         """
         if self.type not in Token.ALLOW_VARIABLES:
             return self._tokenize_no_variables()
-        variables = VariableIterator(self.value)
-        if not variables:
+        matches = VariableMatches(self.value)
+        if not matches:
             return self._tokenize_no_variables()
-        return self._tokenize_variables(variables)
+        return self._tokenize_variables(matches)
 
     def _tokenize_no_variables(self) -> 'Iterator[Token]':
         yield self
 
-    def _tokenize_variables(self, variables) -> 'Iterator[Token]':
+    def _tokenize_variables(self, matches) -> 'Iterator[Token]':
         lineno = self.lineno
         col_offset = self.col_offset
-        remaining = ''
-        for before, variable, remaining in variables:
-            if before:
-                yield Token(self.type, before, lineno, col_offset)
-                col_offset += len(before)
-            yield Token(Token.VARIABLE, variable, lineno, col_offset)
-            col_offset += len(variable)
-        if remaining:
-            yield Token(self.type, remaining, lineno, col_offset)
+        after = ''
+        for match in matches:
+            if match.before:
+                yield Token(self.type, match.before, lineno, col_offset)
+            yield Token(Token.VARIABLE, match.match, lineno, col_offset + match.start)
+            col_offset += match.end
+            after = match.after
+        if after:
+            yield Token(self.type, after, lineno, col_offset)
 
     def __str__(self) -> str:
         return self.value

{robotframework-6.1.1 → robotframework-7.0}/src/robot/parsing/model/blocks.py

@@ -13,6 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import warnings
 from abc import ABC
 from contextlib import contextmanager
 from pathlib import Path
@@ -24,7 +25,7 @@ from .statements import (Break, Continue, ElseHeader, ElseIfHeader, End, ExceptH
                          Error, FinallyHeader, ForHeader, IfHeader, KeywordCall,
                          KeywordName, Node, ReturnSetting, ReturnStatement,
                          SectionHeader, Statement, TemplateArguments, TestCaseName,
-                         TryHeader, WhileHeader)
+                         TryHeader, Var, WhileHeader)
 from .visitor import ModelVisitor
 from ..lexer import Token
 
@@ -97,7 +98,7 @@ class Block(Container, ABC):
 
     def _body_is_empty(self):
         # This works with tests, keywords, and blocks inside them, not with sections.
-        valid = (KeywordCall, TemplateArguments, Continue, Break, ReturnSetting,
+        valid = (KeywordCall, TemplateArguments, Var, Continue, Break, ReturnSetting,
                  ReturnStatement, NestedBlock, Error)
         return not any(isinstance(node, valid) for node in self.body)
 
@@ -255,8 +256,14 @@ class For(NestedBlock):
     header: ForHeader
 
     @property
-    def variables(self) -> 'tuple[str, ...]':
-        return self.header.variables
+    def assign(self) -> 'tuple[str, ...]':
+        return self.header.assign
+
+    @property
+    def variables(self) -> 'tuple[str, ...]':    # TODO: Remove in RF 8.0.
+        warnings.warn("'For.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'For.assign' instead.")
+        return self.assign
 
     @property
     def values(self) -> 'tuple[str, ...]':
@@ -307,8 +314,14 @@ class Try(NestedBlock):
         return getattr(self.header, 'pattern_type', None)
 
     @property
-    def variable(self) -> 'str|None':
-        return getattr(self.header, 'variable', None)
+    def assign(self) -> 'str|None':
+        return getattr(self.header, 'assign', None)
+
+    @property
+    def variable(self) -> 'str|None':    # TODO: Remove in RF 8.0.
+        warnings.warn("'Try.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'Try.assign' instead.")
+        return self.assign
 
     def validate(self, ctx: 'ValidationContext'):
         self._validate_body()