feat(langserver): resolve variable in hover for documentation settings in testcases and keywords

closes #326

Author: d-biehl

Diff for: packages/language_server/src/robotcode/language_server/robotframework/parts/hover.py

@@ -184,11 +184,19 @@ def _hover_default(self, nodes: List[ast.AST], document: TextDocument, position:
                 )
 
                 if found_range is not None:
-                    result.append((found_range, kw.to_markdown()))
+                    txt = kw.to_markdown()
+                    if kw.libtype == "RESOURCE":
+                        txt = namespace.imports_manager.replace_variables_scalar(
+                            txt,
+                            str(document.uri.to_path().parent),
+                            namespace.get_resolvable_variables(nodes, position),
+                        )
+                    result.append((found_range, txt))
             if result:
                 r = result[0][0]
                 if all(r == i[0] for i in result):
                     doc = "\n\n---\n\n".join(i[1] for i in result)
+
                     return Hover(
                         contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=doc),
                         range=r,
@@ -233,6 +241,7 @@ def hover_TestCase(  # noqa: N802
         document: TextDocument,
         position: Position,
     ) -> Optional[Hover]:
+        namespace = self.parent.documents_cache.get_namespace(document)
         test_case = cast(TestCase, node)
 
         if not position.is_in_range(range_from_node(test_case.header)):
@@ -259,6 +268,11 @@ def hover_TestCase(  # noqa: N802
             txt += "\n*Tags*: "
             txt += f"{', '.join(tags.values)}\n"
 
+        txt = namespace.imports_manager.replace_variables_scalar(
+            txt,
+            str(document.uri.to_path().parent),
+            namespace.get_resolvable_variables(nodes, position),
+        )
         return Hover(
             contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=MarkDownFormatter().format(txt)),
             range=range_from_token(name_token),

Diff for: packages/robot/src/robotcode/robot/diagnostics/imports_manager.py

@@ -64,6 +64,7 @@
     get_variables_doc,
     is_library_by_path,
     is_variables_by_path,
+    replace_variables_scalar,
     resolve_args,
     resolve_variable,
 )
@@ -1572,3 +1573,17 @@ def resolve_variable(
             self.get_resolvable_command_line_variables(),
             variables,
         )
+
+    def replace_variables_scalar(
+        self,
+        scalar: str,
+        base_dir: str = ".",
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        return replace_variables_scalar(
+            scalar,
+            str(self.root_folder),
+            base_dir,
+            self.get_resolvable_command_line_variables(),
+            variables,
+        )

Diff for: packages/robot/src/robotcode/robot/diagnostics/library_doc.py

@@ -45,12 +45,8 @@
 from robot.parsing.lexer.tokens import Token as RobotToken
 from robot.parsing.model.blocks import Keyword
 from robot.parsing.model.statements import Arguments, KeywordName
-from robot.running.arguments.argumentresolver import (
-    ArgumentResolver,
-    DictToKwargs,
-    NamedArgumentResolver,
-    VariableReplacer,
-)
+from robot.running.arguments.argumentresolver import ArgumentResolver, DictToKwargs, NamedArgumentResolver
+from robot.running.arguments.argumentresolver import VariableReplacer as ArgumentsVariableReplacer
 from robot.running.arguments.argumentspec import ArgInfo
 from robot.running.arguments.argumentspec import (
     ArgumentSpec as RobotArgumentSpec,
@@ -64,6 +60,7 @@
 from robot.variables import Variables
 from robot.variables.filesetter import PythonImporter, YamlImporter
 from robot.variables.finders import VariableFinder
+from robot.variables.replacer import VariableReplacer
 from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.core.utils.path import normalized_path
@@ -578,9 +575,9 @@ def _raise_positional_after_named(self) -> None:
 
         positional, named = MyNamedArgumentResolver(self.__robot_arguments).resolve(arguments, variables)
         if get_robot_version() < (7, 0):
-            positional, named = VariableReplacer(resolve_variables_until).replace(positional, named, variables)
+            positional, named = ArgumentsVariableReplacer(resolve_variables_until).replace(positional, named, variables)
         else:
-            positional, named = VariableReplacer(self.__robot_arguments, resolve_variables_until).replace(
+            positional, named = ArgumentsVariableReplacer(self.__robot_arguments, resolve_variables_until).replace(
                 positional, named, variables
             )
         positional, named = DictToKwargs(self.__robot_arguments, dict_to_kwargs).handle(positional, named)
@@ -1585,6 +1582,26 @@ def resolve_variable(
     return name.replace("\\", "\\\\")
 
 
+def replace_variables_scalar(
+    scalar: str,
+    working_dir: str = ".",
+    base_dir: str = ".",
+    command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
+    variables: Optional[Dict[str, Optional[Any]]] = None,
+) -> Any:
+
+    _update_env(working_dir)
+
+    if contains_variable(scalar, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+        if get_robot_version() >= (6, 1):
+            return VariableReplacer(robot_variables).replace_scalar(scalar.replace("\\", "\\\\"))
+
+        return VariableReplacer(robot_variables.store).replace_scalar(scalar.replace("\\", "\\\\"))
+
+    return scalar.replace("\\", "\\\\")
+
+
 @contextmanager
 def _std_capture() -> Iterator[io.StringIO]:
     old__stdout__ = sys.__stdout__