finetuning libdoc generation and completions

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/entities.py

@@ -15,7 +15,7 @@
 
 
 def single_call(func: _F) -> _F:
-    name = f"__A_{func.__name__}__result"
+    name = f"__single_result_{func.__name__}__"
 
     def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
 

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -360,13 +360,17 @@ async def _get_document(self) -> TextDocument:
         return self._document
 
     async def get_namespace(self) -> Namespace:
-        return await self.parent.parent_protocol.documents_cache.get_resource_namespace(await self.get_document())
+        async with self._lock:
+            return await self._get_namespace()
+
+    async def _get_namespace(self) -> Namespace:
+        return await self.parent.parent_protocol.documents_cache.get_resource_namespace(await self._get_document())
 
     async def get_libdoc(self) -> LibraryDoc:
         if self._lib_doc is None:
             async with self._lock:
                 if self._lib_doc is None:
-                    self._lib_doc = await (await self.get_namespace()).get_library_doc()
+                    self._lib_doc = await (await self._get_namespace()).get_library_doc()
         return self._lib_doc
 
 
@@ -945,13 +949,15 @@ def _create_handler(self, kw: Any) -> Any:
                     end_line_no=-1,
                     libname=libdoc.name,
                     libtype=libdoc.type,
+                    longname=f"{libdoc.name}.{kw[0].name}",
                     is_embedded=is_embedded_keyword(kw[0].name),
                     errors=getattr(kw[1], "errors") if hasattr(kw[1], "errors") else None,
                     is_error_handler=isinstance(kw[1], UserErrorHandler),
                     error_handler_message=str(cast(UserErrorHandler, kw[1]).error)
                     if isinstance(kw[1], UserErrorHandler)
                     else None,
                     arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
+                    parent=libdoc,
                 )
                 for kw in [(KeywordDocBuilder(resource=True).build_keyword(lw), lw) for lw in lib.handlers]
             ],

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -340,6 +340,8 @@ class KeywordDoc(SourceEntity):
         default=None, compare=False, repr=False, hash=False
     )
 
+    parent: Optional[LibraryDoc] = None
+
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.args)})"
 
@@ -394,7 +396,7 @@ def range(self) -> Range:
                 ),
             )
 
-    def to_markdown(self, add_signature: bool = True, header_level: int = 0, add_type: bool = True) -> str:
+    def to_markdown(self, add_signature: bool = True, header_level: int = 2, add_type: bool = True) -> str:
         result = ""
 
         if add_signature:
@@ -417,10 +419,10 @@ def to_markdown(self, add_signature: bool = True, header_level: int = 0, add_typ
 
     def _get_signature(self, header_level: int, add_type: bool = True) -> str:
         if add_type:
-            result = f"#{'#'*header_level} {'Library' if self.is_initializer else 'Keyword'} *{self.name}*"
+            result = f"#{'#'*header_level} {'Library' if self.is_initializer else 'Keyword'} *{self.name}*\n"
         else:
             if not self.is_initializer:
-                result = f"\n\n#{'#'*header_level} {self.name}"
+                result = f"\n\n#{'#'*header_level} {self.name}\n"
             else:
                 result = ""
 
@@ -575,7 +577,7 @@ class ModuleSpec:
 @dataclass
 class LibraryDoc:
     name: str = ""
-    doc: str = ""
+    doc: str = field(default="", compare=False)
     version: str = ""
     type: str = "LIBRARY"
     scope: str = "TEST"
@@ -592,6 +594,21 @@ class LibraryDoc:
     stdout: Optional[str] = field(default=None, compare=False)
     has_listener: Optional[bool] = None
 
+    @single_call
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.name,
+                self.source,
+                self.line_no,
+                self.end_line_no,
+                self.version,
+                self.type,
+                self.scope,
+                self.doc_format,
+            )
+        )
+
     @property
     def is_deprecated(self) -> bool:
         return DEPRECATED_PATTERN.match(self.doc) is not None
@@ -612,17 +629,19 @@ def range(self) -> Range:
             ),
         )
 
-    def to_markdown(self, add_signature: bool = True, only_doc: bool = True) -> str:
+    def to_markdown(self, add_signature: bool = True, only_doc: bool = True, header_level: int = 2) -> str:
         with io.StringIO(newline="\n") as result:
 
             def write_lines(*args: str) -> None:
                 result.writelines(i + "\n" for i in args)
 
             if add_signature and any(v for v in self.inits.values() if v.args):
                 for i in self.inits.values():
-                    write_lines(i.to_markdown(), "", "---")
+                    write_lines(i.to_markdown(header_level=header_level), "", "---")
 
-            write_lines(f"# {(self.type.capitalize()) if self.type else 'Unknown'} *{self.name}*", "", "")
+            write_lines(
+                f"#{'#'*header_level} {(self.type.capitalize()) if self.type else 'Unknown'} *{self.name}*", "", ""
+            )
 
             if self.version or self.scope:
                 write_lines(
@@ -639,7 +658,7 @@ def write_lines(*args: str) -> None:
 
             if self.doc:
 
-                write_lines("## Introduction", "")
+                write_lines(f"##{'#'*header_level} Introduction", "")
 
                 if self.doc_format == ROBOT_DOC_FORMAT:
                     doc = MarkDownFormatter().format(self.doc)
@@ -655,7 +674,7 @@ def write_lines(*args: str) -> None:
                     result.write(self.doc)
 
             if not only_doc:
-                result.write(self._get_doc_for_keywords())
+                result.write(self._get_doc_for_keywords(header_level=header_level))
 
             return self._link_inline_links(result.getvalue())
 
@@ -680,23 +699,23 @@ def source_or_origin(self) -> Optional[str]:
         re.VERBOSE,
     )
 
-    _headers: ClassVar[re.Pattern] = re.compile(r"^(#{2,5})\s+(\S.*)$", re.MULTILINE)  # type: ignore
+    _headers: ClassVar[re.Pattern] = re.compile(r"^(#{2,9})\s+(\S.*)$", re.MULTILINE)  # type: ignore
 
     def _link_inline_links(self, text: str) -> str:
         headers = [v.group(2) for v in self._headers.finditer(text)]
 
         def repl(m: re.Match) -> str:  # type: ignore
             if m.group(2) in headers:
-                return f"[{str(m.group(2))}](#{str(m.group(2)).lower().replace(' ', '-')})"
+                return f"[{str(m.group(2))}](\\#{str(m.group(2)).lower().replace(' ', '-')})"
             return str(m.group(0))
 
         return str(self._inline_link.sub(repl, text))
 
-    def _get_doc_for_keywords(self) -> str:
+    def _get_doc_for_keywords(self, header_level: int = 2) -> str:
         result = ""
         if any(v for v in self.inits.values() if v.args):
             result += "\n---\n\n"
-            result += "\n## Importing\n\n"
+            result += f"\n##{'#'*header_level} Importing\n\n"
 
             first = True
 
@@ -709,7 +728,7 @@ def _get_doc_for_keywords(self) -> str:
 
         if self.keywords:
             result += "\n---\n\n"
-            result += "\n## Keywords\n\n"
+            result += f"\n##{'#'*header_level} Keywords\n\n"
 
             first = True
 
@@ -718,7 +737,7 @@ def _get_doc_for_keywords(self) -> str:
                     result += "\n---\n"
                 first = False
 
-                result += "\n" + kw.to_markdown(header_level=2, add_type=False)
+                result += "\n" + kw.to_markdown(header_level=header_level, add_type=False)
         return result
 
     def _add_toc(self, doc: str, only_doc: bool = True) -> str:
@@ -1102,6 +1121,21 @@ def find_library(
     )[0]
 
 
+def get_robot_library_html_doc_str(name: str, working_dir: str = ".", base_dir: str = ".") -> str:
+    from robot.libdocpkg import LibraryDocumentation
+    from robot.libdocpkg.htmlwriter import LibdocHtmlWriter
+
+    _update_env(working_dir)
+
+    robot_libdoc = LibraryDocumentation(name)
+    robot_libdoc.convert_docs_to_html()
+    with io.StringIO() as output:
+        writer = LibdocHtmlWriter()
+        writer.write(robot_libdoc, output)
+
+        return output.getvalue()
+
+
 def get_library_doc(
     name: str,
     args: Optional[Tuple[Any, ...]] = None,
@@ -1278,6 +1312,7 @@ def get_test_library(
                             doc_format=str(lib.doc_format) or ROBOT_DOC_FORMAT,
                             is_initializer=True,
                             arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
+                            parent=libdoc,
                         )
                         for kw in [
                             (KeywordDocBuilder().build_keyword(k), k) for k in [KeywordWrapper(lib.init, source)]
@@ -1326,6 +1361,7 @@ def get_test_library(
                             arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments)
                             if not kw[1].is_error_handler
                             else None,
+                            parent=libdoc,
                         )
                         for kw in [
                             (KeywordDocBuilder().build_keyword(k), k)