robotframework 7.1.1__zip → 7.2b1__zip

robotframework-7.2b1/src/robot/output/outputfile.py

@@ -0,0 +1,174 @@
+#  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 pathlib import Path
+
+from robot.errors import DataError
+from robot.utils import get_error_message
+
+from .loggerapi import LoggerApi
+from .loglevel import LogLevel
+from .jsonlogger import JsonLogger
+from .xmllogger import LegacyXmlLogger, NullLogger, XmlLogger
+
+
+class OutputFile(LoggerApi):
+
+    def __init__(self, path: 'Path|None', log_level: LogLevel, rpa: bool = False,
+                 legacy_output: bool = False):
+        # `self.logger` is replaced with `NullLogger` when flattening.
+        self.logger = self.real_logger = self._get_logger(path, rpa, legacy_output)
+        self.is_logged = log_level.is_logged
+        self.flatten_level = 0
+        self.errors = []
+
+    def _get_logger(self, path, rpa, legacy_output):
+        if not path:
+            return NullLogger()
+        try:
+            file = open(path, 'w', encoding='UTF-8')
+        except Exception:
+            raise DataError(f"Opening output file '{path}' failed: "
+                            f"{get_error_message()}")
+        if path.suffix.lower() == '.json':
+            return JsonLogger(file, rpa)
+        if legacy_output:
+            return LegacyXmlLogger(file, rpa)
+        return XmlLogger(file, rpa)
+
+    def start_suite(self, data, result):
+        self.logger.start_suite(result)
+
+    def end_suite(self, data, result):
+        self.logger.end_suite(result)
+
+    def start_test(self, data, result):
+        self.logger.start_test(result)
+
+    def end_test(self, data, result):
+        self.logger.end_test(result)
+
+    def start_keyword(self, data, result):
+        self.logger.start_keyword(result)
+        if result.tags.robot('flatten'):
+            self.flatten_level += 1
+            self.logger = NullLogger()
+
+    def end_keyword(self, data, result):
+        if self.flatten_level and result.tags.robot('flatten'):
+            self.flatten_level -= 1
+            if self.flatten_level == 0:
+                self.logger = self.real_logger
+        self.logger.end_keyword(result)
+
+    def start_for(self, data, result):
+        self.logger.start_for(result)
+
+    def end_for(self, data, result):
+        self.logger.end_for(result)
+
+    def start_for_iteration(self, data, result):
+        self.logger.start_for_iteration(result)
+
+    def end_for_iteration(self, data, result):
+        self.logger.end_for_iteration(result)
+
+    def start_while(self, data, result):
+        self.logger.start_while(result)
+
+    def end_while(self, data, result):
+        self.logger.end_while(result)
+
+    def start_while_iteration(self, data, result):
+        self.logger.start_while_iteration(result)
+
+    def end_while_iteration(self, data, result):
+        self.logger.end_while_iteration(result)
+
+    def start_if(self, data, result):
+        self.logger.start_if(result)
+
+    def end_if(self, data, result):
+        self.logger.end_if(result)
+
+    def start_if_branch(self, data, result):
+        self.logger.start_if_branch(result)
+
+    def end_if_branch(self, data, result):
+        self.logger.end_if_branch(result)
+
+    def start_try(self, data, result):
+        self.logger.start_try(result)
+
+    def end_try(self, data, result):
+        self.logger.end_try(result)
+
+    def start_try_branch(self, data, result):
+        self.logger.start_try_branch(result)
+
+    def end_try_branch(self, data, result):
+        self.logger.end_try_branch(result)
+
+    def start_group(self, data, result):
+        self.logger.start_group(result)
+
+    def end_group(self, data, result):
+        self.logger.end_group(result)
+
+    def start_var(self, data, result):
+        self.logger.start_var(result)
+
+    def end_var(self, data, result):
+        self.logger.end_var(result)
+
+    def start_break(self, data, result):
+        self.logger.start_break(result)
+
+    def end_break(self, data, result):
+        self.logger.end_break(result)
+
+    def start_continue(self, data, result):
+        self.logger.start_continue(result)
+
+    def end_continue(self, data, result):
+        self.logger.end_continue(result)
+
+    def start_return(self, data, result):
+        self.logger.start_return(result)
+
+    def end_return(self, data, result):
+        self.logger.end_return(result)
+
+    def start_error(self, data, result):
+        self.logger.start_error(result)
+
+    def end_error(self, data, result):
+        self.logger.end_error(result)
+
+    def log_message(self, message):
+        if self.is_logged(message):
+            # Use the real logger also when flattening.
+            self.real_logger.message(message)
+
+    def message(self, message):
+        if message.level in ('WARN', 'ERROR'):
+            self.errors.append(message)
+
+    def statistics(self, stats):
+        self.logger.statistics(stats)
+
+    def close(self):
+        self.logger.errors(self.errors)
+        self.logger.close()

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/pyloggingconf.py

@@ -36,6 +36,7 @@ def robot_handler_enabled(level):
         return
     handler = RobotHandler()
     old_raise = logging.raiseExceptions
+    old_level = root.level
     root.addHandler(handler)
     logging.raiseExceptions = False
     set_level(level)
@@ -43,6 +44,7 @@ def robot_handler_enabled(level):
         yield
     finally:
         root.removeHandler(handler)
+        root.setLevel(old_level)
         logging.raiseExceptions = old_raise
 
 

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/xmllogger.py

@@ -19,189 +19,43 @@ from robot.utils import NullMarkupWriter, XmlWriter
 from robot.version import get_full_version
 from robot.result import Keyword, TestCase, TestSuite, ResultVisitor
 
-from .loggerapi import LoggerApi
-from .loggerhelper import IsLogged
-
-
-class XmlLoggerAdapter(LoggerApi):
-
-    def __init__(self, path, log_level='TRACE', rpa=False, generator='Robot',
-                 legacy_output=False):
-        logger = XmlLogger if not legacy_output else LegacyXmlLogger
-        self.logger = logger(path, log_level, rpa, generator)
-
-    @property
-    def flatten_level(self):
-        return self.logger.flatten_level
-
-    def close(self):
-        self.logger.close()
-
-    def set_log_level(self, level):
-        return self.logger.set_log_level(level)
-
-    def start_suite(self, data, result):
-        self.logger.start_suite(result)
-
-    def end_suite(self, data, result):
-        self.logger.end_suite(result)
-
-    def start_test(self, data, result):
-        self.logger.start_test(result)
-
-    def end_test(self, data, result):
-        self.logger.end_test(result)
-
-    def start_keyword(self, data, result):
-        self.logger.start_keyword(result)
-
-    def end_keyword(self, data, result):
-        self.logger.end_keyword(result)
-
-    def start_for(self, data, result):
-        self.logger.start_for(result)
-
-    def end_for(self, data, result):
-        self.logger.end_for(result)
-
-    def start_for_iteration(self, data, result):
-        self.logger.start_for_iteration(result)
-
-    def end_for_iteration(self, data, result):
-        self.logger.end_for_iteration(result)
-
-    def start_while(self, data, result):
-        self.logger.start_while(result)
-
-    def end_while(self, data, result):
-        self.logger.end_while(result)
-
-    def start_while_iteration(self, data, result):
-        self.logger.start_while_iteration(result)
-
-    def end_while_iteration(self, data, result):
-        self.logger.end_while_iteration(result)
-
-    def start_if(self, data, result):
-        self.logger.start_if(result)
-
-    def end_if(self, data, result):
-        self.logger.end_if(result)
-
-    def start_if_branch(self, data, result):
-        self.logger.start_if_branch(result)
-
-    def end_if_branch(self, data, result):
-        self.logger.end_if_branch(result)
-
-    def start_try(self, data, result):
-        self.logger.start_try(result)
-
-    def end_try(self, data, result):
-        self.logger.end_try(result)
-
-    def start_try_branch(self, data, result):
-        self.logger.start_try_branch(result)
-
-    def end_try_branch(self, data, result):
-        self.logger.end_try_branch(result)
-
-    def start_var(self, data, result):
-        self.logger.start_var(result)
-
-    def end_var(self, data, result):
-        self.logger.end_var(result)
-
-    def start_break(self, data, result):
-        self.logger.start_break(result)
-
-    def end_break(self, data, result):
-        self.logger.end_break(result)
-
-    def start_continue(self, data, result):
-        self.logger.start_continue(result)
-
-    def end_continue(self, data, result):
-        self.logger.end_continue(result)
-
-    def start_return(self, data, result):
-        self.logger.start_return(result)
-
-    def end_return(self, data, result):
-        self.logger.end_return(result)
-
-    def start_error(self, data, result):
-        self.logger.start_error(result)
-
-    def end_error(self, data, result):
-        self.logger.end_error(result)
-
-    def log_message(self, message):
-        self.logger.log_message(message)
-
-    def message(self, message):
-        self.logger.message(message)
-
 
 class XmlLogger(ResultVisitor):
+    generator = 'Robot'
 
-    def __init__(self, output, log_level='TRACE', rpa=False, generator='Robot',
-                 suite_only=False):
-        self._log_message_is_logged = IsLogged(log_level)
-        self._error_message_is_logged = IsLogged('WARN')
-        # `_writer` is set to NullMarkupWriter when flattening, `_xml_writer` is not.
-        self._writer = self._xml_writer = self._get_writer(output, rpa, generator,
-                                                           suite_only)
-        self.flatten_level = 0
-        self._errors = []
-
-    def _get_writer(self, output, rpa, generator, suite_only):
-        if not output:
-            return NullMarkupWriter()
-        writer = XmlWriter(output, write_empty=False, usage='output',
-                           preamble=not suite_only)
+    def __init__(self, output, rpa=False, suite_only=False):
+        self._writer = self._get_writer(output, preamble=not suite_only)
         if not suite_only:
-            writer.start('robot', self._get_start_attrs(rpa, generator))
-        return writer
+            self._writer.start('robot', self._get_start_attrs(rpa))
+
+    def _get_writer(self, output, preamble=True):
+        return XmlWriter(output, usage='output', write_empty=False, preamble=preamble)
 
-    def _get_start_attrs(self, rpa, generator):
-        return {'generator': get_full_version(generator),
+    def _get_start_attrs(self, rpa):
+        return {'generator': get_full_version(self.generator),
                 'generated': datetime.now().isoformat(),
                 'rpa': 'true' if rpa else 'false',
                 'schemaversion': '5'}
 
     def close(self):
-        self.start_errors()
-        for msg in self._errors:
-            self._write_message(msg)
-        self.end_errors()
         self._writer.end('robot')
         self._writer.close()
 
-    def set_log_level(self, level):
-        return self._log_message_is_logged.set_level(level)
+    def visit_message(self, msg):
+        self._write_message(msg)
 
     def message(self, msg):
-        if self._error_message_is_logged(msg.level):
-            self._errors.append(msg)
-
-    def log_message(self, msg):
-        if self._log_message_is_logged(msg.level):
-            self._write_message(msg)
+        self._write_message(msg)
 
     def _write_message(self, msg):
         attrs = {'time': msg.timestamp.isoformat() if msg.timestamp else None,
                  'level': msg.level}
         if msg.html:
             attrs['html'] = 'true'
-        # Use `_xml_writer`, not `_writer` to write messages also when flattening.
-        self._xml_writer.element('msg', msg.message, attrs)
+        self._writer.element('msg', msg.message, attrs)
 
     def start_keyword(self, kw):
         self._writer.start('kw', self._get_start_keyword_attrs(kw))
-        if kw.tags.robot('flatten'):
-            self.flatten_level += 1
-            self._writer = NullMarkupWriter()
 
     def _get_start_keyword_attrs(self, kw):
         attrs = {'name': kw.name, 'owner': kw.owner}
@@ -212,10 +66,6 @@ class XmlLogger(ResultVisitor):
         return attrs
 
     def end_keyword(self, kw):
-        if kw.tags.robot('flatten'):
-            self.flatten_level -= 1
-            if self.flatten_level == 0:
-                self._writer = self._xml_writer
         self._write_list('var', kw.assign)
         self._write_list('arg', [str(a) for a in kw.args])
         self._write_list('tag', kw.tags)
@@ -304,6 +154,13 @@ class XmlLogger(ResultVisitor):
         self._write_status(iteration)
         self._writer.end('iter')
 
+    def start_group(self, group):
+        self._writer.start('group', {'name': group.name})
+
+    def end_group(self, group):
+        self._write_status(group)
+        self._writer.end('group')
+
     def start_var(self, var):
         attr = {'name': var.name}
         if var.scope is not None:
@@ -375,6 +232,9 @@ class XmlLogger(ResultVisitor):
         self._write_status(suite)
         self._writer.end('suite')
 
+    def statistics(self, stats):
+        self.visit_statistics(stats)
+
     def start_statistics(self, stats):
         self._writer.start('statistics')
 
@@ -403,10 +263,13 @@ class XmlLogger(ResultVisitor):
         self._writer.element('stat', stat.name,
                              stat.get_attributes(values_as_strings=True))
 
-    def start_errors(self, errors=None):
+    def errors(self, errors):
+        self.visit_errors(errors)
+
+    def start_errors(self, errors):
         self._writer.start('errors')
 
-    def end_errors(self, errors=None):
+    def end_errors(self, errors):
         self._writer.end('errors')
 
     def _write_list(self, tag, items):
@@ -422,8 +285,8 @@ class XmlLogger(ResultVisitor):
 
 class LegacyXmlLogger(XmlLogger):
 
-    def _get_start_attrs(self, rpa, generator):
-        return {'generator': get_full_version(generator),
+    def _get_start_attrs(self, rpa):
+        return {'generator': get_full_version(self.generator),
                 'generated': self._datetime_to_timestamp(datetime.now()),
                 'rpa': 'true' if rpa else 'false',
                 'schemaversion': '4'}
@@ -457,5 +320,13 @@ class LegacyXmlLogger(XmlLogger):
         attrs = {'timestamp':  ts, 'level': msg.level}
         if msg.html:
             attrs['html'] = 'true'
-        # Use `_xml_writer`, not `_writer` to write messages also when flattening.
-        self._xml_writer.element('msg', msg.message, attrs)
+        self._writer.element('msg', msg.message, attrs)
+
+
+class NullLogger(XmlLogger):
+
+    def __init__(self):
+        super().__init__(None)
+
+    def _get_writer(self, output, preamble=True):
+        return NullMarkupWriter()

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/parsing/lexer/blocklexers.py

@@ -23,7 +23,7 @@ from .context import (FileContext, KeywordContext, LexingContext, SuiteFileConte
 from .statementlexers import (BreakLexer, CommentLexer, CommentSectionHeaderLexer,
                               ContinueLexer, ElseHeaderLexer, ElseIfHeaderLexer,
                               EndLexer, ExceptHeaderLexer, FinallyHeaderLexer,
-                              ForHeaderLexer, IfHeaderLexer, ImplicitCommentLexer,
+                              ForHeaderLexer, GroupHeaderLexer, IfHeaderLexer, ImplicitCommentLexer,
                               InlineIfHeaderLexer, InvalidSectionHeaderLexer,
                               KeywordCallLexer, KeywordSectionHeaderLexer,
                               KeywordSettingLexer, Lexer, ReturnLexer, SettingLexer,
@@ -202,7 +202,7 @@ class TestCaseLexer(TestOrKeywordLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (TestCaseSettingLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer,
-                WhileLexer, VarLexer, SyntaxErrorLexer, KeywordCallLexer)
+                WhileLexer, GroupLexer, VarLexer, SyntaxErrorLexer,  KeywordCallLexer)
 
 
 class KeywordLexer(TestOrKeywordLexer):
@@ -213,7 +213,7 @@ class KeywordLexer(TestOrKeywordLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (KeywordSettingLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer,
-                WhileLexer, VarLexer, ReturnLexer, SyntaxErrorLexer, KeywordCallLexer)
+                WhileLexer, GroupLexer, VarLexer, ReturnLexer, SyntaxErrorLexer, KeywordCallLexer)
 
 
 class NestedBlockLexer(BlockLexer, ABC):
@@ -230,7 +230,7 @@ class NestedBlockLexer(BlockLexer, ABC):
         super().input(statement)
         lexer = self.lexers[-1]
         if isinstance(lexer, (ForHeaderLexer, IfHeaderLexer, TryHeaderLexer,
-                              WhileHeaderLexer)):
+                              WhileHeaderLexer, GroupHeaderLexer)):
             self._block_level += 1
         if isinstance(lexer, EndLexer):
             self._block_level -= 1
@@ -243,8 +243,8 @@ class ForLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (ForHeaderLexer, InlineIfLexer, IfLexer, TryLexer, WhileLexer, EndLexer,
-                VarLexer, ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
-                KeywordCallLexer)
+                GroupLexer, VarLexer, ReturnLexer, ContinueLexer, BreakLexer,
+                SyntaxErrorLexer, KeywordCallLexer)
 
 
 class WhileLexer(NestedBlockLexer):
@@ -254,8 +254,8 @@ class WhileLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (WhileHeaderLexer, ForLexer, InlineIfLexer, IfLexer, TryLexer, EndLexer,
-                VarLexer, ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
-                KeywordCallLexer)
+                GroupLexer, VarLexer, ReturnLexer, ContinueLexer, BreakLexer,
+                SyntaxErrorLexer, KeywordCallLexer)
 
 
 class TryLexer(NestedBlockLexer):
@@ -266,7 +266,19 @@ class TryLexer(NestedBlockLexer):
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (TryHeaderLexer, ExceptHeaderLexer, ElseHeaderLexer, FinallyHeaderLexer,
                 ForLexer, InlineIfLexer, IfLexer, WhileLexer, EndLexer, VarLexer,
-                ReturnLexer, BreakLexer, ContinueLexer, SyntaxErrorLexer,
+                GroupLexer, ReturnLexer, BreakLexer, ContinueLexer, SyntaxErrorLexer,
+                KeywordCallLexer)
+
+
+class GroupLexer(NestedBlockLexer):
+
+    def handles(self, statement: StatementTokens) -> bool:
+        return GroupHeaderLexer(self.ctx).handles(statement)
+
+    def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
+        return (GroupHeaderLexer, InlineIfLexer, IfLexer,
+                ForLexer, TryLexer, WhileLexer, EndLexer, VarLexer,
+                ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
                 KeywordCallLexer)
 
 
@@ -277,8 +289,9 @@ class IfLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (InlineIfLexer, IfHeaderLexer, ElseIfHeaderLexer, ElseHeaderLexer,
-                ForLexer, TryLexer, WhileLexer, EndLexer, VarLexer, ReturnLexer,
-                ContinueLexer, BreakLexer, SyntaxErrorLexer, KeywordCallLexer)
+                ForLexer, TryLexer, WhileLexer, EndLexer, VarLexer, GroupLexer,
+                ReturnLexer, ContinueLexer, BreakLexer, SyntaxErrorLexer,
+                KeywordCallLexer)
 
 
 class InlineIfLexer(NestedBlockLexer):
@@ -293,7 +306,7 @@ class InlineIfLexer(NestedBlockLexer):
 
     def lexer_classes(self) -> 'tuple[type[Lexer], ...]':
         return (InlineIfHeaderLexer, ElseIfHeaderLexer, ElseHeaderLexer, VarLexer,
-                ReturnLexer, ContinueLexer, BreakLexer, KeywordCallLexer)
+                GroupLexer, ReturnLexer, ContinueLexer, BreakLexer, KeywordCallLexer)
 
     def input(self, statement: StatementTokens):
         for part in self._split(statement):

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/parsing/lexer/statementlexers.py

@@ -135,17 +135,19 @@ class ImplicitCommentLexer(CommentLexer):
 
     def input(self, statement: StatementTokens):
         super().input(statement)
-        if len(statement) == 1 and statement[0].value.lower().startswith('language:'):
-            lang = statement[0].value.split(':', 1)[1].strip()
+        if statement[0].value.lower().startswith('language:'):
+            value = ' '.join(token.value for token in statement)
+            lang = value.split(':', 1)[1].strip()
             try:
                 self.ctx.add_language(lang)
             except DataError:
-                statement[0].set_error(
-                    f"Invalid language configuration: "
-                    f"Language '{lang}' not found nor importable as a language module."
-                )
+                for token in statement:
+                    token.set_error(f"Invalid language configuration: "
+                                    f"Language '{lang}' not found nor importable "
+                                    f"as a language module.")
             else:
-                statement[0].type = Token.CONFIG
+                for token in statement:
+                    token.type = Token.CONFIG
 
     def lex(self):
         for token in self.statement:
@@ -333,6 +335,13 @@ class WhileHeaderLexer(StatementLexer):
         self._lex_options('limit', 'on_limit', 'on_limit_message')
 
 
+class GroupHeaderLexer(TypeAndArguments):
+    token_type = Token.GROUP
+
+    def handles(self, statement: StatementTokens) -> bool:
+        return statement[0].value == 'GROUP'
+
+
 class EndLexer(TypeAndArguments):
     token_type = Token.END
 

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/parsing/lexer/tokens.py

@@ -102,6 +102,7 @@ class Token:
     CONTINUE = 'CONTINUE'
     BREAK = 'BREAK'
     OPTION = 'OPTION'
+    GROUP = 'GROUP'
 
     SEPARATOR = 'SEPARATOR'
     COMMENT = 'COMMENT'
@@ -172,7 +173,7 @@ class Token:
                 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'
+                Token.AS: 'AS', Token.GROUP: 'GROUP'
             }.get(type, '')    # type: ignore
         self.value = cast(str, value)
         self.lineno = lineno

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/parsing/model/__init__.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from .blocks import (Block, CommentSection, Container, File, For, If,
+from .blocks import (Block, CommentSection, Container, File, For, If, Group,
                      ImplicitCommentSection, InvalidSection, Keyword,
                      KeywordSection, NestedBlock, Section, SettingSection,
                      TestCase, TestCaseSection, Try, VariableSection, While)