robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/api/logger.py

@@ -39,7 +39,7 @@ It is possible to log messages using levels ``TRACE``, ``DEBUG``, ``INFO``,
 commonly, with the log level specific :func:`trace`, :func:`debug`,
 :func:`info`, :func:`warn`, :func:`error` functions.
 
-By default the trace and debug messages are not logged but that can be
+The trace and debug messages are not logged by default, but that can be
 changed with the ``--loglevel`` command line option. Warnings and errors are
 automatically written also to the console and to the *Test Execution Errors*
 section in the log file.
@@ -60,18 +60,22 @@ Example
     from robot.api import logger
 
     def my_keyword(arg):
-        logger.debug('Got argument %s.' % arg)
+        logger.debug(f'Got argument {arg}.')
         do_something()
         logger.info('<i>This</i> is a boring example.', html=True)
 """
 
 import logging
+from typing import Literal
 
 from robot.output import librarylogger
 from robot.running.context import EXECUTION_CONTEXTS
 
 
-def write(msg, level='INFO', html=False):
+LOGLEVEL = Literal['TRACE', 'DEBUG', 'INFO', 'CONSOLE', 'HTML', 'WARN', 'ERROR']
+
+
+def write(msg: str, level: LOGLEVEL = 'INFO', html: bool = False):
     """Writes the message to the log file using the given level.
 
     Valid log levels are ``TRACE``, ``DEBUG``, ``INFO`` (default), ``WARN``,
@@ -89,27 +93,29 @@ def write(msg, level='INFO', html=False):
         librarylogger.write(msg, level, html)
     else:
         logger = logging.getLogger("RobotFramework")
-        level = {'TRACE': logging.DEBUG // 2,
-                 'DEBUG': logging.DEBUG,
-                 'INFO': logging.INFO,
-                 'CONSOLE': logging.INFO,
-                 'HTML': logging.INFO,
-                 'WARN': logging.WARN,
-                 'ERROR': logging.ERROR}[level]
-        logger.log(level, msg)
-
-
-def trace(msg, html=False):
+        level_int = {
+            'TRACE': logging.DEBUG // 2,
+            'DEBUG': logging.DEBUG,
+            'INFO': logging.INFO,
+            'CONSOLE': logging.INFO,
+            'HTML': logging.INFO,
+            'WARN': logging.WARN,
+            'ERROR': logging.ERROR
+        }[level]
+        logger.log(level_int, msg)
+
+
+def trace(msg: str, html: bool = False):
     """Writes the message to the log file using the ``TRACE`` level."""
     write(msg, 'TRACE', html)
 
 
-def debug(msg, html=False):
+def debug(msg: str, html: bool = False):
     """Writes the message to the log file using the ``DEBUG`` level."""
     write(msg, 'DEBUG', html)
 
 
-def info(msg, html=False, also_console=False):
+def info(msg: str, html: bool = False, also_console: bool = False):
     """Writes the message to the log file using the ``INFO`` level.
 
     If ``also_console`` argument is set to ``True``, the message is
@@ -120,24 +126,25 @@ def info(msg, html=False, also_console=False):
         console(msg)
 
 
-def warn(msg, html=False):
+def warn(msg: str, html: bool = False):
     """Writes the message to the log file using the ``WARN`` level."""
     write(msg, 'WARN', html)
 
 
-def error(msg, html=False):
+def error(msg: str, html: bool = False):
     """Writes the message to the log file using the ``ERROR`` level.
     """
     write(msg, 'ERROR', html)
 
 
-def console(msg, newline=True, stream='stdout'):
+def console(msg: str, newline: bool = True,
+            stream: Literal['stdout', 'stderr'] = 'stdout'):
     """Writes the message to the console.
 
     If the ``newline`` argument is ``True``, a newline character is
     automatically added to the message.
 
-    By default the message is written to the standard output stream.
+    The message is written to the standard output stream by default.
     Using the standard error stream is possibly by giving the ``stream``
     argument value ``'stderr'``.
     """

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

@@ -223,7 +223,7 @@ Statements:
 - :class:`~robot.parsing.model.statements.Template`
 - :class:`~robot.parsing.model.statements.Timeout`
 - :class:`~robot.parsing.model.statements.Arguments`
-- :class:`~robot.parsing.model.statements.Return` (deprecated, will mean ``ReturnStatement`` in RF 7.0)
+- :class:`~robot.parsing.model.statements.Return` (deprecated, will mean ``ReturnStatement`` in RF 8.0)
 - :class:`~robot.parsing.model.statements.ReturnSetting` (alias for ``Return``, new in RF 6.1)
 - :class:`~robot.parsing.model.statements.KeywordCall`
 - :class:`~robot.parsing.model.statements.TemplateArguments`
@@ -236,6 +236,7 @@ Statements:
 - :class:`~robot.parsing.model.statements.FinallyHeader`
 - :class:`~robot.parsing.model.statements.ForHeader`
 - :class:`~robot.parsing.model.statements.WhileHeader`
+- :class:`~robot.parsing.model.statements.Var` (new in RF 7.0)
 - :class:`~robot.parsing.model.statements.End`
 - :class:`~robot.parsing.model.statements.ReturnStatement`
 - :class:`~robot.parsing.model.statements.Break`
@@ -519,7 +520,7 @@ from robot.parsing.model.statements import (
     TestTeardown,
     TestTemplate,
     TestTimeout,
-    ForceTags,
+    TestTags,
     DefaultTags,
     KeywordTags,
     Variable,
@@ -545,6 +546,7 @@ from robot.parsing.model.statements import (
     ForHeader,
     WhileHeader,
     End,
+    Var,
     ReturnStatement,
     Continue,
     Break,

{robotframework-6.1.1 → robotframework-7.0}/src/robot/conf/gatherfailed.py

@@ -26,7 +26,7 @@ class GatherFailedTests(SuiteVisitor):
 
     def visit_test(self, test):
         if test.failed:
-            self.tests.append(glob_escape(test.longname))
+            self.tests.append(glob_escape(test.full_name))
 
     def visit_keyword(self, kw):
         pass
@@ -39,7 +39,7 @@ class GatherFailedSuites(SuiteVisitor):
 
     def start_suite(self, suite):
         if any(test.failed for test in suite.tests):
-            self.suites.append(glob_escape(suite.longname))
+            self.suites.append(glob_escape(suite.full_name))
 
     def visit_test(self, test):
         pass

{robotframework-6.1.1 → robotframework-7.0}/src/robot/conf/languages.py

@@ -130,15 +130,6 @@ class Languages:
             languages = [languages]
         if add_english:
             languages.append(En())
-            # The English singular forms are added for backwards compatibility
-            self.headers = {
-                'Setting': 'Settings',
-                'Variable': 'Variables',
-                'Test Case': 'Test Cases',
-                'Task': 'Tasks',
-                'Keyword': 'Keywords',
-                'Comment': 'Comments'
-            }
         return languages
 
     def _get_available_languages(self) -> 'dict[str, type[Language]]':

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

@@ -18,15 +18,15 @@ import os
 import random
 import string
 import sys
-import time
 import warnings
+from datetime import datetime
 from pathlib import Path
 
 from robot.errors import DataError, FrameworkError
 from robot.output import LOGGER, loggerhelper
 from robot.result.keywordremover import KeywordRemover
 from robot.result.flattenkeywordmatcher import validate_flatten_keyword
-from robot.utils import (abspath, create_destination_directory, escape, format_time,
+from robot.utils import (abspath, create_destination_directory, escape,
                          get_link_path, html_escape, is_list_like, plural_or_not as s,
                          seq2str, split_args_from_name_or_path)
 
@@ -47,6 +47,7 @@ class _BaseSettings:
                  'Include'          : ('include', []),
                  'Exclude'          : ('exclude', []),
                  'OutputDir'        : ('outputdir', abspath('.')),
+                 'LegacyOutput'     : ('legacyoutput', False),
                  'Log'              : ('log', 'log.html'),
                  'Report'           : ('report', 'report.html'),
                  'XUnit'            : ('xunit', None),
@@ -73,7 +74,7 @@ class _BaseSettings:
     _output_opts = ['Output', 'Log', 'Report', 'XUnit', 'DebugFile']
 
     def __init__(self, options=None, **extra_options):
-        self.start_timestamp = format_time(time.time(), '', '-', '')
+        self.start_time = datetime.now()
         self._opts = {}
         self._cli_opts = self._cli_opts.copy()
         self._cli_opts.update(self._extra_cli_opts)
@@ -112,7 +113,7 @@ class _BaseSettings:
                 return str(value)
             return value if value and value.upper() != 'NONE' else None
         if name == 'OutputDir':
-            return abspath(value)
+            return Path(value).absolute()
         if name in ['SuiteStatLevel', 'ConsoleWidth']:
             return self._convert_to_positive_integer_or_default(name, value)
         if name == 'VariableFiles':
@@ -223,14 +224,16 @@ class _BaseSettings:
             LOGGER.error('Log file cannot be created if output.xml is disabled.')
             return None
         name = self._process_output_name(option, name)
-        path = abspath(os.path.join(self['OutputDir'], name))
+        path = self.output_directory / name
         create_destination_directory(path, f'{option.lower()} file')
         return path
 
     def _process_output_name(self, option, name):
         base, ext = os.path.splitext(name)
         if self['TimestampOutputs']:
-            base = f'{base}-{self.start_timestamp}'
+            s = self.start_time
+            base = (f'{base}-{s.year}{s.month:02}{s.day:02}-'
+                    f'{s.hour:02}{s.minute:02}{s.second:02}')
         ext = self._get_output_extension(ext, option)
         return base + ext
 
@@ -336,7 +339,7 @@ class _BaseSettings:
     def _validate_remove_keywords(self, values):
         for value in values:
             try:
-                KeywordRemover(value)
+                KeywordRemover.from_config(value)
             except DataError as err:
                 self._raise_invalid('RemoveKeywords', err)
 
@@ -362,23 +365,27 @@ class _BaseSettings:
         return '\n'.join(f'{name}: {self._opts[name]}' for name in sorted(self._opts))
 
     @property
-    def output_directory(self):
-        return self['OutputDir']
+    def output_directory(self) -> Path:
+        return Path(self['OutputDir'])
 
     @property
-    def output(self):
+    def output(self) -> 'Path|None':
         return self['Output']
 
     @property
-    def log(self):
+    def legacy_output(self) -> bool:
+        return self['LegacyOutput']
+
+    @property
+    def log(self) -> 'Path|None':
         return self['Log']
 
     @property
-    def report(self):
+    def report(self) -> 'Path|None':
         return self['Report']
 
     @property
-    def xunit(self):
+    def xunit(self) -> 'Path|None':
         return self['XUnit']
 
     @property
@@ -488,7 +495,7 @@ class RobotSettings(_BaseSettings):
 
     def get_rebot_settings(self):
         settings = RebotSettings()
-        settings.start_timestamp = self.start_timestamp
+        settings.start_time = self.start_time
         not_copied = {'Include', 'Exclude', 'TestNames', 'SuiteNames', 'ParseInclude',
                       'Name', 'Doc', 'Metadata', 'SetTag', 'Output', 'LogLevel',
                       'TimestampOutputs'}

{robotframework-6.1.1 → robotframework-7.0}/src/robot/htmldata/common/storage.js

@@ -4,7 +4,8 @@ storage = function () {
     var storage;
 
     function init(user) {
-        prefix += user + '-';
+        if (user)
+            prefix += user + '-';
         storage = getStorage();
     }
 
@@ -20,16 +21,20 @@ storage = function () {
         }
     }
 
-    function get(name, defaultValue) {
-        var value = storage[prefix + name];
+    function get(key, defaultValue) {
+        var value = storage[fullKey(key)];
         if (typeof value === 'undefined')
             return defaultValue;
         return value;
     }
 
-    function set(name, value) {
-        storage[prefix + name] = value;
+    function set(key, value) {
+        storage[fullKey(key)] = value;
     }
 
-    return {init: init, get: get, set: set};
+    function fullKey(key) {
+        return prefix + key;
+    }
+
+    return {init: init, get: get, set: set, fullKey: fullKey};
 }();

{robotframework-6.1.1 → robotframework-7.0}/src/robot/htmldata/htmlfilewriter.py

@@ -113,4 +113,4 @@ class CssFileWriter(InliningWriter):
 
     def write(self, line: str):
         href, media = re.search('href="([^"]+)" media="([^"]+)"', line).groups()
-        self.inline_file(href, 'style', {'type': 'text/css', 'media': media})
+        self.inline_file(href, 'style', {'media': media})

{robotframework-6.1.1 → robotframework-7.0}/src/robot/htmldata/libdoc/libdoc.css

@@ -288,6 +288,7 @@ input.hamburger-menu:checked ~ span.hamburger-menu-3
 
 .arguments-list-container {
     overflow-y: auto;
+    margin-bottom: 1.33rem;
 }
 
 
@@ -338,7 +339,8 @@ input.hamburger-menu:checked ~ span.hamburger-menu-3
     min-width: 150px;
 }
 
-.arguments-list .arg-type {
+.arguments-list .arg-type,
+.return-type .arg-type {
     margin-left: 2rem;
     -ms-grid-column: 3;
     grid-column: 3;
@@ -347,6 +349,11 @@ input.hamburger-menu:checked ~ span.hamburger-menu-3
     -webkit-text-size-adjust: none;
 }
 
+.tags .kw-tags {
+    margin-left: 2rem;
+    display: flex;
+}
+
 .arguments-list .arg-kind {
   color: transparent;
   text-shadow: 0 0 0 var(--less-important-text-color);
@@ -583,6 +590,7 @@ h4 {
 
 .enum-type-members span,
 .args span,
+.return-type span,
 .args a
  {
     font-family: monospace;
@@ -625,7 +633,7 @@ a.type {
     color: var(--highlighted-color);
 }
 
-.tags {
+.tags, .return-type {
     display: flex;
     align-items: baseline;
 }

{robotframework-6.1.1 → robotframework-7.0}/src/robot/htmldata/libdoc/libdoc.html

@@ -536,13 +536,23 @@
                 </div>
               </div>
             {{/if}}
+            {{if returnType}}
+            <div class="return-type">
+              <h4>Return Type</h4>
+              <span class="arg-type">
+              {{tmpl(returnType) 'type-info-template'}}
+              </span>
+            </div>
+            {{/if}}
             {{if libdoc.tags.length && tags.length}}
               <div class="tags">
                 <h4>Tags</h4>
+                <span class="kw-tags">
                 {{each tags}}
                   <a href="javascript:tagSearch('${$value}')"
                     title="Show keywords with this tag">${$value}</a>{{if $index < tags.length-1}},<br>{{/if}}
                 {{/each}}
+                </span>
               </div>
             {{/if}}
           </div>