robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/datatypes.py

@@ -47,12 +47,12 @@ class TypeDoc(Sortable):
         return self.name.lower()
 
     @classmethod
-    def for_type(cls, type_hint, converters):
-        if isinstance(type_hint, EnumType):
-            return cls.for_enum(type_hint)
-        if isinstance(type_hint, typeddict_types):
-            return cls.for_typed_dict(type_hint)
-        converter = TypeConverter.converter_for(type_hint, converters)
+    def for_type(cls, type_info, converters):
+        if isinstance(type_info.type, EnumType):
+            return cls.for_enum(type_info.type)
+        if isinstance(type_info.type, typeddict_types):
+            return cls.for_typed_dict(type_info.type)
+        converter = TypeConverter.converter_for(type_info, converters)
         if not converter:
             return None
         elif not converter.type:
@@ -83,15 +83,14 @@ class TypeDoc(Sortable):
         return cls(cls.TYPED_DICT, typed_dict.__name__, getdoc(typed_dict),
                    accepts=(str, 'Mapping'), items=items)
 
-    def to_dictionary(self, legacy=False):
+    def to_dictionary(self):
         data = {
             'type': self.type,
             'name': self.name,
             'doc': self.doc,
+            'usages': self.usages,
+            'accepts': self.accepts
         }
-        if not legacy:
-            data['usages'] = self.usages
-            data['accepts'] = self.accepts
         if self.members is not None:
             data['members'] = [m.to_dictionary() for m in self.members]
         if self.items is not None:

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/htmlutils.py

@@ -14,10 +14,7 @@
 #  limitations under the License.
 
 import re
-try:
-    from urllib import quote
-except ImportError:
-    from urllib.parse import quote
+from urllib.parse import quote
 
 from robot.errors import DataError
 from robot.utils import html_escape, html_format, NormalizedDict
@@ -97,10 +94,10 @@ class DocToHtml:
                     'HTML': lambda doc: doc,
                     'REST': self._format_rest}[doc_format]
         except KeyError:
-            raise DataError("Invalid documentation format '%s'." % doc_format)
+            raise DataError(f"Invalid documentation format '{doc_format}'.")
 
     def _format_text(self, doc):
-        return '<p style="white-space: pre-wrap">%s</p>' % html_escape(doc)
+        return f'<p style="white-space: pre-wrap">{html_escape(doc)}</p>'
 
     def _format_rest(self, doc):
         try:
@@ -133,7 +130,7 @@ class HtmlToText:
         '&apos;': "'"
     }
 
-    def get_shortdoc_from_html(self, doc):
+    def get_short_doc_from_html(self, doc):
         match = re.search(r'<p.*?>(.*?)</?p>', doc, re.DOTALL)
         if match:
             doc = match.group(1)

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/jsonbuilder.py

@@ -16,7 +16,7 @@
 import json
 import os.path
 
-from robot.running import ArgInfo
+from robot.running import ArgInfo, TypeInfo
 from robot.errors import DataError
 
 from .datatypes import EnumMember, TypedDictItem, TypeDoc
@@ -57,7 +57,7 @@ class JsonDocBuilder:
     def _create_keyword(self, data):
         kw = KeywordDoc(name=data.get('name'),
                         doc=data['doc'],
-                        shortdoc=data['shortdoc'],
+                        short_doc=data['shortdoc'],
                         tags=data['tags'],
                         private=data.get('private', False),
                         deprecated=data.get('deprecated', False),
@@ -83,24 +83,28 @@ class JsonDocBuilder:
             default = arg.get('defaultValue')
             if default is not None:
                 spec.defaults[name] = default
-            if arg.get('type'):
+            if 'type' in arg:    # RF >= 6.1
                 type_docs = {}
-                type_info = self._parse_modern_type_info(arg['type'], type_docs)
-            else:    # Compatibility with RF < 6.1.
+                type_info = self._parse_type_info(arg['type'], type_docs)
+            else:                # RF < 6.1
                 type_docs = arg.get('typedocs', {})
-                type_info = tuple(arg['types'])
+                type_info = self._parse_legacy_type_info(arg['types'])
             if type_info:
                 if not spec.types:
                     spec.types = {}
                 spec.types[name] = type_info
             kw.type_docs[name] = type_docs
 
-    def _parse_modern_type_info(self, data, type_docs):
+    def _parse_type_info(self, data, type_docs):
+        if not data:
+            return None
         if data.get('typedoc'):
             type_docs[data['name']] = data['typedoc']
-        return {'name': data['name'],
-                'nested': [self._parse_modern_type_info(nested, type_docs)
-                           for nested in data.get('nested', ())]}
+        nested = [self._parse_type_info(typ, type_docs) for typ in data.get('nested', ())]
+        return TypeInfo(data['name'], nested=nested)
+
+    def _parse_legacy_type_info(self, types):
+        return TypeInfo.from_sequence(types) if types else None
 
     def _parse_type_docs(self, type_docs):
         for data in type_docs:

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/model.py

@@ -97,9 +97,9 @@ class LibraryDoc:
         formatter = DocFormatter(self.keywords, self.type_docs, self.doc, self.doc_format)
         self._doc = formatter.html(self.doc, intro=True)
         for item in self.inits + self.keywords:
-            # If 'shortdoc' is not set, it is generated automatically based on 'doc'
+            # If 'short_doc' is not set, it is generated automatically based on 'doc'
             # when accessed. Generate and set it to avoid HTML format affecting it.
-            item.shortdoc = item.shortdoc
+            item.short_doc = item.short_doc
             item.doc = formatter.html(item.doc)
         for type_doc in self.type_docs:
             # Standard docs are always in ROBOT format ...
@@ -113,7 +113,7 @@ class LibraryDoc:
 
     def to_dictionary(self, include_private=False, theme=None):
         data = {
-            'specversion': 2,
+            'specversion': 3,
             'name': self.name,
             'doc': self.doc,
             'version': self.version,
@@ -127,22 +127,12 @@ class LibraryDoc:
             'inits': [init.to_dictionary() for init in self.inits],
             'keywords': [kw.to_dictionary() for kw in self.keywords
                          if include_private or not kw.private],
-            # 'dataTypes' was deprecated in RF 5, 'typedoc' should be used instead.
-            'dataTypes': self._get_data_types(self.type_docs),
             'typedocs': [t.to_dictionary() for t in sorted(self.type_docs)]
         }
         if theme:
             data['theme'] = theme.lower()
         return data
 
-    def _get_data_types(self, types):
-        enums = sorted(t for t in types if t.type == 'Enum')
-        typed_dicts = sorted(t for t in types if t.type == 'TypedDict')
-        return {
-            'enums': [t.to_dictionary(legacy=True) for t in enums],
-            'typedDicts': [t.to_dictionary(legacy=True) for t in typed_dicts]
-        }
-
     def to_json(self, indent=None, include_private=True, theme=None):
         data = self.to_dictionary(include_private, theme)
         return json.dumps(data, indent=indent)
@@ -151,12 +141,12 @@ class LibraryDoc:
 class KeywordDoc(Sortable):
     """Documentation for a single keyword or an initializer."""
 
-    def __init__(self, name='', args=None, doc='', shortdoc='', tags=(), private=False,
+    def __init__(self, name='', args=None, doc='', short_doc='', tags=(), private=False,
                  deprecated=False, source=None, lineno=-1, parent=None):
         self.name = name
         self.args = args or ArgumentSpec()
         self.doc = doc
-        self._shortdoc = shortdoc
+        self._short_doc = short_doc
         self.tags = Tags(tags)
         self.private = private
         self.deprecated = deprecated
@@ -167,19 +157,19 @@ class KeywordDoc(Sortable):
         self.type_docs = {arg.name: {} for arg in self.args}
 
     @property
-    def shortdoc(self):
-        return self._shortdoc or self._doc_to_shortdoc()
+    def short_doc(self):
+        return self._short_doc or self._doc_to_short_doc()
 
-    def _doc_to_shortdoc(self):
+    def _doc_to_short_doc(self):
         if self.parent and self.parent.doc_format == 'HTML':
-            doc = HtmlToText().get_shortdoc_from_html(self.doc)
+            doc = HtmlToText().get_short_doc_from_html(self.doc)
         else:
             doc = self.doc
         return ' '.join(getshortdoc(doc).splitlines())
 
-    @shortdoc.setter
-    def shortdoc(self, shortdoc):
-        self._shortdoc = shortdoc
+    @short_doc.setter
+    def short_doc(self, short_doc):
+        self._short_doc = short_doc
 
     @property
     def _sort_key(self):
@@ -190,7 +180,7 @@ class KeywordDoc(Sortable):
             'name': self.name,
             'args': [self._arg_to_dict(arg) for arg in self.args],
             'doc': self.doc,
-            'shortdoc': self.shortdoc,
+            'shortdoc': self.short_doc,
             'tags': list(self.tags),
             'source': str(self.source) if self.source else None,
             'lineno': self.lineno
@@ -206,8 +196,6 @@ class KeywordDoc(Sortable):
         return {
             'name': arg.name,
             'type': self._type_to_dict(arg.type, type_docs),
-            'types': arg.types_reprs,
-            'typedocs': type_docs,
             'defaultValue': arg.default_repr,
             'kind': arg.kind,
             'required': arg.required,

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/robotbuilder.py

@@ -18,8 +18,8 @@ import sys
 import re
 
 from robot.errors import DataError
-from robot.running import (ArgInfo, ResourceFileBuilder, TestLibrary, TestSuiteBuilder,
-                           TypeInfo, UserLibrary, UserErrorHandler)
+from robot.running import (ArgumentSpec, ResourceFileBuilder, TestLibrary,
+                           TestSuiteBuilder, TypeInfo, UserLibrary, UserErrorHandler)
 from robot.utils import is_string, split_tags_from_doc, unescape
 from robot.variables import search_variable
 
@@ -61,7 +61,7 @@ class LibraryDocBuilder:
         return lib.doc or f"Documentation for library ``{lib.name}``."
 
     def _get_initializers(self, lib):
-        if lib.init.arguments.maxargs:
+        if lib.init.arguments:
             return [KeywordDocBuilder().build_keyword(lib.init)]
         return []
 
@@ -71,7 +71,7 @@ class LibraryDocBuilder:
             for arg in kw.args:
                 kw.type_docs[arg.name] = {}
                 for type_info in self._yield_type_info(arg.type):
-                    type_doc = TypeDoc.for_type(type_info.type, custom_converters)
+                    type_doc = TypeDoc.for_type(type_info, custom_converters)
                     if type_doc:
                         kw.type_docs[arg.name][type_info.name] = type_doc.name
                         type_docs.setdefault(type_doc, set()).add(kw.name)
@@ -149,6 +149,8 @@ class KeywordDocBuilder:
         doc, tags = self._get_doc_and_tags(kw)
         if not self._resource:
             self._escape_strings_in_defaults(kw.arguments.defaults)
+        if kw.arguments.embedded:
+            self._remove_embedded(kw.arguments)
         return KeywordDoc(name=kw.name,
                           args=kw.arguments,
                           doc=doc,
@@ -185,3 +187,11 @@ class KeywordDocBuilder:
         if self._resource and not isinstance(kw, UserErrorHandler):
             return unescape(kw.doc)
         return kw.doc
+
+    def _remove_embedded(self, spec: ArgumentSpec):
+        embedded = len(spec.embedded)
+        pos_only = len(spec.positional_only)
+        spec.positional_only[:embedded] = []
+        if embedded > pos_only:
+            spec.positional_or_named[:embedded-pos_only] = []
+        spec.embedded = ()

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/xmlbuilder.py

@@ -16,7 +16,7 @@
 import os.path
 
 from robot.errors import DataError
-from robot.running import ArgInfo
+from robot.running import ArgInfo, TypeInfo
 from robot.utils import ET, ETSource
 
 from .datatypes import EnumMember, TypedDictItem, TypeDoc
@@ -52,9 +52,9 @@ class XmlDocBuilder:
         if root.tag != 'keywordspec':
             raise DataError(f"Invalid spec file '{path}'.")
         version = root.get('specversion')
-        if version not in ('3', '4', '5'):
+        if version not in ('3', '4', '5', '6'):
             raise DataError(f"Invalid spec file version '{version}'. "
-                            f"Supported versions are 3, 4 and 5.")
+                            f"Supported versions are 3, 4, 5, and 6.")
         return root
 
     def _create_keywords(self, spec, path, lib_source):
@@ -63,7 +63,7 @@ class XmlDocBuilder:
     def _create_keyword(self, elem, lib_source):
         kw = KeywordDoc(name=elem.get('name', ''),
                         doc=elem.find('doc').text or '',
-                        shortdoc=elem.find('shortdoc').text or '',
+                        short_doc=elem.find('shortdoc').text or '',
                         tags=[t.text for t in elem.findall('tags/tag')],
                         private=elem.get('private', 'false') == 'true',
                         deprecated=elem.get('deprecated', 'false') == 'true',
@@ -108,9 +108,9 @@ class XmlDocBuilder:
         name = type_elem.get('name')
         if type_elem.get('typedoc'):
             type_docs[name] = type_elem.get('typedoc')
-        nested = tuple(self._parse_modern_type_info(child, type_docs)
-                       for child in type_elem.findall('type'))
-        return {'name': name, 'nested': nested}
+        nested = [self._parse_modern_type_info(child, type_docs)
+                  for child in type_elem.findall('type')]
+        return TypeInfo(name, nested=nested)
 
     def _parse_legacy_type_info(self, type_elems, type_docs):
         types = []
@@ -119,7 +119,7 @@ class XmlDocBuilder:
             types.append(name)
             if elem.get('typedoc'):
                 type_docs[name] = elem.get('typedoc')
-        return types
+        return TypeInfo.from_sequence(types) if types else None
 
     def _parse_type_docs(self, spec):
         for elem in spec.findall('typedocs/type'):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/libdocpkg/xmlwriter.py

@@ -14,7 +14,7 @@
 #  limitations under the License.
 
 from robot.running import TypeInfo
-from robot.utils import XmlWriter
+from robot.utils import NOT_SET, XmlWriter
 
 from .output import get_generation_time
 
@@ -26,9 +26,6 @@ class LibdocXmlWriter:
         self._write_start(libdoc, writer)
         self._write_keywords('inits', 'init', libdoc.inits, libdoc.source, writer)
         self._write_keywords('keywords', 'kw', libdoc.keywords, libdoc.source, writer)
-        # Write deprecated '<datatypes>' element.
-        self._write_data_types(libdoc.type_docs, writer)
-        # Write new '<types>' element.
         self._write_type_docs(libdoc.type_docs, writer)
         self._write_end(writer)
 
@@ -38,7 +35,7 @@ class LibdocXmlWriter:
                  'format': libdoc.doc_format,
                  'scope': libdoc.scope,
                  'generated': get_generation_time(),
-                 'specversion': '5'}
+                 'specversion': '6'}
         self._add_source_info(attrs, libdoc)
         writer.start('keywordspec', attrs)
         writer.element('version', libdoc.version)
@@ -58,7 +55,7 @@ class LibdocXmlWriter:
             writer.start(kw_type, attrs)
             self._write_arguments(kw, writer)
             writer.element('doc', kw.doc)
-            writer.element('shortdoc', kw.shortdoc)
+            writer.element('shortdoc', kw.short_doc)
             if kw_type == 'kw' and kw.tags:
                 self._write_tags(kw.tags, writer)
             writer.end(kw_type)
@@ -80,24 +77,24 @@ class LibdocXmlWriter:
                 writer.element('name', arg.name)
             if arg.type:
                 self._write_type_info(arg.type, kw.type_docs[arg.name], writer)
-            if arg.default is not arg.NOTSET:
+            if arg.default is not NOT_SET:
                 writer.element('default', arg.default_repr)
             writer.end('arg')
         writer.end('arguments')
 
-    def _write_type_info(self, type_info: TypeInfo, type_docs: dict, writer, top=True):
+    def _write_type_info(self, type_info: TypeInfo, type_docs: dict, writer):
         attrs = {'name': type_info.name}
         if type_info.is_union:
             attrs['union'] = 'true'
         if type_info.name in type_docs:
             attrs['typedoc'] = type_docs[type_info.name]
-        # Writing content, and omitting newlines, is backwards compatibility with
-        # specs created using RF < 6.1. TODO: Remove in RF 7.
-        writer.start('type', attrs, newline=False)
-        writer.content(str(type_info))
-        for nested in type_info.nested:
-            self._write_type_info(nested, type_docs, writer, top=False)
-        writer.end('type', newline=top)
+        if type_info.nested:
+            writer.start('type', attrs)
+            for nested in type_info.nested:
+                self._write_type_info(nested, type_docs, writer)
+            writer.end('type')
+        else:
+            writer.element('type', attrs=attrs)
 
     def _get_start_attrs(self, kw, lib_source):
         attrs = {'name': kw.name}
@@ -108,29 +105,6 @@ class LibdocXmlWriter:
         self._add_source_info(attrs, kw, lib_source)
         return attrs
 
-    # Write legacy 'datatypes'. TODO: Remove in RF 7.
-    def _write_data_types(self, types, writer):
-        enums = sorted(t for t in types if t.type == 'Enum')
-        typed_dicts = sorted(t for t in types if t.type == 'TypedDict')
-        writer.start('datatypes')
-        if enums:
-            writer.start('enums')
-            for enum in enums:
-                writer.start('enum', {'name': enum.name})
-                writer.element('doc', enum.doc)
-                self._write_enum_members(enum, writer)
-                writer.end('enum')
-            writer.end('enums')
-        if typed_dicts:
-            writer.start('typeddicts')
-            for typ_dict in typed_dicts:
-                writer.start('typeddict', {'name': typ_dict.name})
-                writer.element('doc', typ_dict.doc)
-                self._write_typed_dict_items(typ_dict, writer)
-                writer.end('typeddict')
-            writer.end('typeddicts')
-        writer.end('datatypes')
-
     def _write_type_docs(self, type_docs, writer):
         writer.start('typedocs')
         for doc in sorted(type_docs):