robotframework 6.1rc1__zip → 7.0a1__zip

robotframework-7.0a1/src/robot/output/output.py

@@ -0,0 +1,158 @@
+#  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 . import pyloggingconf
+from .debugfile import DebugFile
+from .listeners import Listeners, LibraryListeners
+from .logger import LOGGER
+from .loggerapi import LoggerApi
+from .loggerhelper import AbstractLogger
+from .xmllogger import XmlLoggerAdapter
+
+
+class Output(AbstractLogger, LoggerApi):
+
+    def __init__(self, settings):
+        AbstractLogger.__init__(self)
+        self._xml_logger = XmlLoggerAdapter(settings.output, settings.log_level,
+                                            settings.rpa)
+        self.listeners = Listeners(settings.listeners, settings.log_level)
+        self.library_listeners = LibraryListeners(settings.log_level)
+        self._register_loggers(DebugFile(settings.debug_file))
+        self._settings = settings
+
+    def _register_loggers(self, debug_file):
+        LOGGER.register_xml_logger(self._xml_logger)
+        LOGGER.register_listeners(self.listeners or None, self.library_listeners)
+        if debug_file:
+            LOGGER.register_logger(debug_file)
+
+    def register_error_listener(self, listener):
+        LOGGER.register_error_listener(listener)
+
+    def close(self, result):
+        self._xml_logger.logger.visit_statistics(result.statistics)
+        self._xml_logger.close()
+        LOGGER.unregister_xml_logger()
+        LOGGER.output_file('Output', self._settings['Output'])
+
+    def start_suite(self, data, result):
+        LOGGER.start_suite(data, result)
+
+    def end_suite(self, data, result):
+        LOGGER.end_suite(data, result)
+
+    def start_test(self, data, result):
+        LOGGER.start_test(data, result)
+
+    def end_test(self, data, result):
+        LOGGER.end_test(data, result)
+
+    def start_keyword(self, data, result):
+        LOGGER.start_keyword(data, result)
+
+    def end_keyword(self, data, result):
+        LOGGER.end_keyword(data, result)
+
+    def start_for(self, data, result):
+        LOGGER.start_for(data, result)
+
+    def end_for(self, data, result):
+        LOGGER.end_for(data, result)
+
+    def start_for_iteration(self, data, result):
+        LOGGER.start_for_iteration(data, result)
+
+    def end_for_iteration(self, data, result):
+        LOGGER.end_for_iteration(data, result)
+
+    def start_while(self, data, result):
+        LOGGER.start_while(data, result)
+
+    def end_while(self, data, result):
+        LOGGER.end_while(data, result)
+
+    def start_while_iteration(self, data, result):
+        LOGGER.start_while_iteration(data, result)
+
+    def end_while_iteration(self, data, result):
+        LOGGER.end_while_iteration(data, result)
+
+    def start_if(self, data, result):
+        LOGGER.start_if(data, result)
+
+    def end_if(self, data, result):
+        LOGGER.end_if(data, result)
+
+    def start_if_branch(self, data, result):
+        LOGGER.start_if_branch(data, result)
+
+    def end_if_branch(self, data, result):
+        LOGGER.end_if_branch(data, result)
+
+    def start_try(self, data, result):
+        LOGGER.start_try(data, result)
+
+    def end_try(self, data, result):
+        LOGGER.end_try(data, result)
+
+    def start_try_branch(self, data, result):
+        LOGGER.start_try_branch(data, result)
+
+    def end_try_branch(self, data, result):
+        LOGGER.end_try_branch(data, result)
+
+    def start_var(self, data, result):
+        LOGGER.start_var(data, result)
+
+    def end_var(self, data, result):
+        LOGGER.end_var(data, result)
+
+    def start_break(self, data, result):
+        LOGGER.start_break(data, result)
+
+    def end_break(self, data, result):
+        LOGGER.end_break(data, result)
+
+    def start_continue(self, data, result):
+        LOGGER.start_continue(data, result)
+
+    def end_continue(self, data, result):
+        LOGGER.end_continue(data, result)
+
+    def start_return(self, data, result):
+        LOGGER.start_return(data, result)
+
+    def end_return(self, data, result):
+        LOGGER.end_return(data, result)
+
+    def start_error(self, data, result):
+        LOGGER.start_error(data, result)
+
+    def end_error(self, data, result):
+        LOGGER.end_error(data, result)
+
+    def message(self, msg):
+        LOGGER.log_message(msg)
+
+    def trace(self, msg, write_if_flat=True):
+        if write_if_flat or not self._xml_logger.flatten_level:
+            self.write(msg, 'TRACE')
+
+    def set_log_level(self, level):
+        pyloggingconf.set_level(level)
+        self.listeners.set_log_level(level)
+        self.library_listeners.set_log_level(level)
+        return self._xml_logger.set_log_level(level)

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/output/stdoutlogsplitter.py

@@ -14,8 +14,8 @@
 #  limitations under the License.
 
 import re
+from datetime import datetime
 
-from robot.utils import format_time
 from .loggerhelper import Message, write_to_console
 
 
@@ -36,7 +36,7 @@ class StdoutLogSplitter:
                 write_to_console(msg.lstrip())
                 level = 'INFO'
             if timestamp:
-                timestamp = self._format_timestamp(timestamp[1:])
+                timestamp = datetime.fromtimestamp(float(timestamp[1:]) / 1000)
             yield Message(msg.strip(), level, timestamp=timestamp)
 
     def _split_output(self, output):
@@ -53,8 +53,11 @@ class StdoutLogSplitter:
     def _output_started_with_level(self, tokens):
         return tokens[0] == ''
 
-    def _format_timestamp(self, millis):
-        return format_time(float(millis)/1000, millissep='.')
-
     def __iter__(self):
         return iter(self._messages)
+
+    def __len__(self):
+        return len(self._messages)
+
+    def __getitem__(self, item):
+        return self._messages[item]

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/output/xmllogger.py

@@ -13,19 +13,142 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import get_timestamp, NullMarkupWriter, safe_str, XmlWriter
+from datetime import datetime
+
+from robot.utils import NullMarkupWriter, safe_str, XmlWriter
 from robot.version import get_full_version
 from robot.result.visitor import ResultVisitor
 
+from .loggerapi import LoggerApi
 from .loggerhelper import IsLogged
 
 
+class XmlLoggerAdapter(LoggerApi):
+
+    def __init__(self, path, log_level='TRACE', rpa=False, generator='Robot'):
+        self.logger = XmlLogger(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):
 
     def __init__(self, path, log_level='TRACE', rpa=False, generator='Robot'):
         self._log_message_is_logged = IsLogged(log_level)
         self._error_message_is_logged = IsLogged('WARN')
-        self._writer = self._get_writer(path, rpa, generator)
+        # `_writer` is set to NullMarkupWriter when flattening, `_xml_writer` is not.
+        self._writer = self._xml_writer = self._get_writer(path, rpa, generator)
+        self.flatten_level = 0
         self._errors = []
 
     def _get_writer(self, path, rpa, generator):
@@ -33,9 +156,9 @@ class XmlLogger(ResultVisitor):
             return NullMarkupWriter()
         writer = XmlWriter(path, write_empty=False, usage='output')
         writer.start('robot', {'generator': get_full_version(generator),
-                               'generated': get_timestamp(),
+                               'generated': datetime.now().isoformat(),
                                'rpa': 'true' if rpa else 'false',
-                               'schemaversion': '4'})
+                               'schemaversion': '5'})
         return writer
 
     def close(self):
@@ -58,25 +181,33 @@ class XmlLogger(ResultVisitor):
             self._write_message(msg)
 
     def _write_message(self, msg):
-        attrs = {'timestamp': msg.timestamp or 'N/A', 'level': msg.level}
+        attrs = {'time': msg.timestamp.isoformat() if msg.timestamp else None,
+                 'level': msg.level}
         if msg.html:
             attrs['html'] = 'true'
-        self._writer.element('msg', msg.message, attrs)
+        # Use `_xml_writer`, not `_writer` to write messages also when flattening.
+        self._xml_writer.element('msg', msg.message, attrs)
 
     def start_keyword(self, kw):
-        attrs = {'name': kw.kwname, 'library': kw.libname}
+        attrs = {'name': kw.name, 'owner': kw.owner}
         if kw.type != 'KEYWORD':
             attrs['type'] = kw.type
-        if kw.sourcename:
-            attrs['sourcename'] = kw.sourcename
+        if kw.source_name:
+            attrs['source_name'] = kw.source_name
         self._writer.start('kw', attrs)
         self._write_list('var', kw.assign)
         self._write_list('arg', [safe_str(a) for a in kw.args])
         self._write_list('tag', kw.tags)
-        # Must be after tags to allow adding message when using --flattenkeywords.
         self._writer.element('doc', kw.doc)
+        if kw.tags.robot('flatten'):
+            self.flatten_level += 1
+            self._writer = NullMarkupWriter()
 
     def end_keyword(self, kw):
+        if kw.tags.robot('flatten'):
+            self.flatten_level -= 1
+            if self.flatten_level == 0:
+                self._writer = self._xml_writer
         if kw.timeout:
             self._writer.element('timeout', attrs={'value': str(kw.timeout)})
         self._write_status(kw)
@@ -84,7 +215,6 @@ class XmlLogger(ResultVisitor):
 
     def start_if(self, if_):
         self._writer.start('if')
-        self._writer.element('doc', if_.doc)
 
     def end_if(self, if_):
         self._write_status(if_)
@@ -93,7 +223,6 @@ class XmlLogger(ResultVisitor):
     def start_if_branch(self, branch):
         self._writer.start('branch', {'type': branch.type,
                                       'condition': branch.condition})
-        self._writer.element('doc', branch.doc)
 
     def end_if_branch(self, branch):
         self._write_status(branch)
@@ -104,11 +233,10 @@ class XmlLogger(ResultVisitor):
                                    'start': for_.start,
                                    'mode': for_.mode,
                                    'fill': for_.fill})
-        for name in for_.variables:
+        for name in for_.assign:
             self._writer.element('var', name)
         for value in for_.values:
             self._writer.element('value', value)
-        self._writer.element('doc', for_.doc)
 
     def end_for(self, for_):
         self._write_status(for_)
@@ -116,9 +244,8 @@ class XmlLogger(ResultVisitor):
 
     def start_for_iteration(self, iteration):
         self._writer.start('iter')
-        for name, value in iteration.variables.items():
+        for name, value in iteration.assign.items():
             self._writer.element('var', value, {'name': name})
-        self._writer.element('doc', iteration.doc)
 
     def end_for_iteration(self, iteration):
         self._write_status(iteration)
@@ -134,8 +261,9 @@ class XmlLogger(ResultVisitor):
     def start_try_branch(self, branch):
         if branch.type == branch.EXCEPT:
             self._writer.start('branch', attrs={
-                'type': 'EXCEPT', 'variable': branch.variable,
-                'pattern_type': branch.pattern_type
+                'type': 'EXCEPT',
+                'pattern_type': branch.pattern_type,
+                'assign': branch.assign
             })
             self._write_list('pattern', branch.patterns)
         else:
@@ -152,7 +280,6 @@ class XmlLogger(ResultVisitor):
             'on_limit': while_.on_limit,
             'on_limit_message': while_.on_limit_message
         })
-        self._writer.element('doc', while_.doc)
 
     def end_while(self, while_):
         self._write_status(while_)
@@ -160,12 +287,25 @@ class XmlLogger(ResultVisitor):
 
     def start_while_iteration(self, iteration):
         self._writer.start('iter')
-        self._writer.element('doc', iteration.doc)
 
     def end_while_iteration(self, iteration):
         self._write_status(iteration)
         self._writer.end('iter')
 
+    def start_var(self, var):
+        attr = {'name': var.name}
+        if var.scope is not None:
+            attr['scope'] = var.scope
+        if var.separator is not None:
+            attr['separator'] = var.separator
+        self._writer.start('variable', attr, write_empty=True)
+        for val in var.value:
+            self._writer.element('var', val)
+
+    def end_var(self, var):
+        self._write_status(var)
+        self._writer.end('variable')
+
     def start_return(self, return_):
         self._writer.start('return')
         for value in return_.values:
@@ -262,93 +402,7 @@ class XmlLogger(ResultVisitor):
             self._writer.element(tag, item)
 
     def _write_status(self, item):
-        attrs = {'status': item.status, 'starttime': item.starttime or 'N/A',
-                 'endtime': item.endtime or 'N/A'}
-        if not (item.starttime and item.endtime):
-            attrs['elapsedtime'] = str(item.elapsedtime)
+        attrs = {'status': item.status,
+                 'start': item.start_time.isoformat() if item.start_time else None,
+                 'elapsed': format(item.elapsed_time.total_seconds(), 'f')}
         self._writer.element('status', item.message, attrs)
-
-
-class FlatXmlLogger(XmlLogger):
-
-    def __init__(self, real_xml_logger):
-        super().__init__(None)
-        self._writer = real_xml_logger._writer
-
-    def start_keyword(self, kw):
-        pass
-
-    def end_keyword(self, kw):
-        pass
-
-    def start_for(self, for_):
-        pass
-
-    def end_for(self, for_):
-        pass
-
-    def start_for_iteration(self, iteration):
-        pass
-
-    def end_for_iteration(self, iteration):
-        pass
-
-    def start_if(self, if_):
-        pass
-
-    def end_if(self, if_):
-        pass
-
-    def start_if_branch(self, branch):
-        pass
-
-    def end_if_branch(self, branch):
-        pass
-
-    def start_try(self, root):
-        pass
-
-    def end_try(self, root):
-        pass
-
-    def start_try_branch(self, branch):
-        pass
-
-    def end_try_branch(self, branch):
-        pass
-
-    def start_while(self, while_):
-        pass
-
-    def end_while(self, while_):
-        pass
-
-    def start_while_iteration(self, iteration):
-        pass
-
-    def end_while_iteration(self, iteration):
-        pass
-
-    def start_break(self, break_):
-        pass
-
-    def end_break(self, break_):
-        pass
-
-    def start_continue(self, continue_):
-        pass
-
-    def end_continue(self, continue_):
-        pass
-
-    def start_return(self, return_):
-        pass
-
-    def end_return(self, return_):
-        pass
-
-    def start_error(self, error):
-        pass
-
-    def end_error(self, error):
-        pass

{robotframework-6.1rc1 → robotframework-7.0a1}/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.1rc1 → robotframework-7.0a1}/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.1rc1 → robotframework-7.0a1}/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