feat: show more informations in hint over a variables import

Author: d-biehl

Diff for: packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -1103,7 +1103,8 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     except BaseException as e:
                         self._logger.exception(e)
 
-            with ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn")) as executor:
+            executor = ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn"))
+            try:
                 result = await asyncio.wait_for(
                     asyncio.get_running_loop().run_in_executor(
                         executor,
@@ -1117,6 +1118,13 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     ),
                     LOAD_LIBRARY_TIME_OUT,
                 )
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as e:
+                self._logger.exception(e)
+                raise
+            finally:
+                executor.shutdown(wait=True)
 
             if result.stdout:
                 self._logger.warning(lambda: f"stdout captured at loading library {name}{args!r}:\n{result.stdout}")
@@ -1350,7 +1358,8 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     except BaseException as e:
                         self._logger.exception(e)
 
-            with ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn")) as executor:
+            executor = ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn"))
+            try:
                 result = await asyncio.wait_for(
                     asyncio.get_running_loop().run_in_executor(
                         executor,
@@ -1364,32 +1373,38 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     ),
                     LOAD_LIBRARY_TIME_OUT,
                 )
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as e:
+                self._logger.exception(e)
+                raise
+            finally:
+                executor.shutdown(True)
 
-                if result.stdout:
-                    self._logger.warning(
-                        lambda: f"stdout captured at loading variables {name}{args!r}:\n{result.stdout}"
-                    )
+            if result.stdout:
+                self._logger.warning(lambda: f"stdout captured at loading variables {name}{args!r}:\n{result.stdout}")
 
-                try:
-                    if meta is not None:
-                        meta_file = Path(self.variables_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
-                        spec_file = Path(self.variables_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
-                        spec_file.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                if meta is not None:
+                    meta_file = Path(self.variables_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
+                    spec_file = Path(self.variables_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
+                    spec_file.parent.mkdir(parents=True, exist_ok=True)
 
-                        try:
-                            spec_file.write_text(as_json(result), "utf-8")
-                        except (SystemExit, KeyboardInterrupt):
-                            raise
-                        except BaseException as e:
-                            raise RuntimeError(f"Cannot write spec file for variables '{name}' to '{spec_file}'") from e
-                        meta_file.write_text(as_json(meta), "utf-8")
-                    else:
-                        self._logger.debug(lambda: f"Skip caching variables {name}{args!r}")
-                except (SystemExit, KeyboardInterrupt):
-                    raise
-                except BaseException as e:
-                    self._logger.exception(e)
-                return result
+                    try:
+                        spec_file.write_text(as_json(result), "utf-8")
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except BaseException as e:
+                        raise RuntimeError(f"Cannot write spec file for variables '{name}' to '{spec_file}'") from e
+                    meta_file.write_text(as_json(meta), "utf-8")
+                else:
+                    self._logger.debug(lambda: f"Skip caching variables {name}{args!r}")
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as e:
+                self._logger.exception(e)
+
+            return result
 
         resolved_args = resolve_args(
             args,

Diff for: packages/language_server/src/robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -851,13 +851,57 @@ def _create_toc(self, doc: str, only_doc: bool = True) -> str:
         return "\n".join(f"- [{entry}](#{entry.lower().replace(' ', '-')})" for entry in entries)
 
 
+def var_repr(value: Any) -> str:
+    if value is None:
+        return ""
+
+    if isinstance(value, NativeValue):
+        value = value.value
+
+    if value is None:
+        return "${None}"
+
+    if isinstance(value, (int, float, bool)):
+        return f"${{{value!r}}}"
+
+    if isinstance(value, str) and value == "":
+        return "${EMPTY}"
+
+    if isinstance(value, str) and value == "\\ \\":
+        return "${SPACE}"
+
+    if isinstance(value, str):
+        return value
+
+    return "${{ " + repr(value) + " }}"
+
+
 @dataclass
 class VariablesDoc(LibraryDoc):
     type: str = "VARIABLES"
     scope: str = "GLOBAL"
 
     variables: List[ImportedVariableDefinition] = field(default_factory=list)
 
+    def to_markdown(self, add_signature: bool = True, only_doc: bool = True, header_level: int = 2) -> str:
+        result = super().to_markdown(add_signature, only_doc, header_level)
+
+        if self.variables:
+            result += "\n---\n\n"
+
+            result += "\n```robotframework"
+            result += "\n*** Variables ***"
+
+            for var in self.variables:
+                result += "\n" + var.name
+                if var.has_value:
+                    result += "    " + var_repr(var.value)
+                else:
+                    result += "    ..."
+            result += "\n```"
+
+        return result
+
 
 def is_library_by_path(path: str) -> bool:
     return path.lower().endswith((".py", "/", os.sep))
@@ -1563,7 +1607,7 @@ def get_variables_doc(
 ) -> VariablesDoc:
     from robot.libdocpkg.robotbuilder import KeywordDocBuilder
     from robot.output import LOGGER
-    from robot.running.handlers import _PythonHandler
+    from robot.running.handlers import _PythonHandler, _PythonInitHandler
     from robot.utils.importer import Importer
     from robot.variables.filesetter import PythonImporter, YamlImporter
 
@@ -1575,6 +1619,8 @@ def get_variables_doc(
     module_spec: Optional[ModuleSpec] = None
     source: Optional[str] = None
     try:
+        python_import = False
+
         with _std_capture() as std_capturer:
             import_name = find_variables(name, working_dir, base_dir, command_line_variables, variables)
             get_variables = None
@@ -1586,6 +1632,8 @@ def get_variables_doc(
                 source = import_name
                 importer = JsonImporter()
             else:
+                python_import = True
+
                 if not is_variables_by_path(import_name):
                     module_spec = get_module_spec(import_name)
 
@@ -1645,43 +1693,80 @@ def is_dynamic(self) -> bool:
                 python_path=sys.path,
             )
 
-            if get_variables is not None:
-
-                class VarHandler(_PythonHandler):
-                    def _get_name(self, handler_name: Any, handler_method: Any) -> Any:
-                        return get_variables.__name__ if get_variables is not None else ""
-
-                    def _get_initial_handler(self, library: Any, name: Any, method: Any) -> Any:
-                        return None
-
-                vars_initializer = VarHandler(libdoc, get_variables.__name__, get_variables)
-
-                libdoc.inits = KeywordStore(
-                    keywords=[
-                        KeywordDoc(
-                            name=libdoc.name,
-                            args=[KeywordArgumentDoc.from_robot(a) for a in kw[0].args],
-                            doc=kw[0].doc,
-                            tags=list(kw[0].tags),
-                            source=kw[0].source,
-                            line_no=kw[0].lineno if kw[0].lineno is not None else -1,
-                            col_offset=-1,
-                            end_col_offset=-1,
-                            end_line_no=-1,
-                            type="library",
-                            libname=libdoc.name,
-                            libtype=libdoc.type,
-                            longname=f"{libdoc.name}.{kw[0].name}",
-                            is_initializer=True,
-                            arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
-                            parent=libdoc.digest,
-                        )
-                        for kw in [
-                            (KeywordDocBuilder().build_keyword(k), k)
-                            for k in [KeywordWrapper(vars_initializer, libdoc.source or "")]
+            if python_import:
+                if get_variables is not None:
+
+                    class VarHandler(_PythonHandler):
+                        def _get_name(self, handler_name: Any, handler_method: Any) -> Any:
+                            return get_variables.__name__ if get_variables is not None else ""
+
+                        def _get_initial_handler(self, library: Any, name: Any, method: Any) -> Any:
+                            return None
+
+                    vars_initializer = VarHandler(libdoc, get_variables.__name__, get_variables)
+
+                    libdoc.inits = KeywordStore(
+                        keywords=[
+                            KeywordDoc(
+                                name=libdoc.name,
+                                args=[KeywordArgumentDoc.from_robot(a) for a in kw[0].args],
+                                doc=kw[0].doc,
+                                source=kw[0].source,
+                                line_no=kw[0].lineno if kw[0].lineno is not None else -1,
+                                col_offset=-1,
+                                end_col_offset=-1,
+                                end_line_no=-1,
+                                type="library",
+                                libname=libdoc.name,
+                                libtype=libdoc.type,
+                                longname=f"{libdoc.name}.{kw[0].name}",
+                                is_initializer=True,
+                                arguments=ArgumentSpec.from_robot_argument_spec(kw[1].arguments),
+                                parent=libdoc.digest,
+                            )
+                            for kw in [
+                                (KeywordDocBuilder().build_keyword(k), k)
+                                for k in [KeywordWrapper(vars_initializer, libdoc.source or "")]
+                            ]
                         ]
-                    ]
-                )
+                    )
+                else:
+                    get_variables = getattr(libcode, "__init__", None) or getattr(libcode, "__init__", None)
+
+                    class InitVarHandler(_PythonInitHandler):
+                        def _get_name(self, handler_name: Any, handler_method: Any) -> Any:
+                            return get_variables.__name__ if get_variables is not None else ""
+
+                        def _get_initial_handler(self, library: Any, name: Any, method: Any) -> Any:
+                            return None
+
+                    if get_variables is not None:
+                        vars_initializer = InitVarHandler(libdoc, get_variables.__name__, get_variables, None)
+
+                        libdoc.inits = KeywordStore(
+                            keywords=[
+                                KeywordDoc(
+                                    name=libdoc.name,
+                                    args=[],
+                                    doc=kw[0].doc,
+                                    source=kw[0].source,
+                                    line_no=kw[0].lineno if kw[0].lineno is not None else -1,
+                                    col_offset=-1,
+                                    end_col_offset=-1,
+                                    end_line_no=-1,
+                                    type="library",
+                                    libname=libdoc.name,
+                                    libtype=libdoc.type,
+                                    longname=f"{libdoc.name}.{kw[0].name}",
+                                    is_initializer=True,
+                                    parent=libdoc.digest,
+                                )
+                                for kw in [
+                                    (KeywordDocBuilder().build_keyword(k), k)
+                                    for k in [KeywordWrapper(vars_initializer, libdoc.source or "")]
+                                ]
+                            ]
+                        )
 
             return libdoc
     except (SystemExit, KeyboardInterrupt, IgnoreEasterEggLibraryWarning):