Support for simple values (number, bool, str) from variable and yaml files

Author: d-biehl

CHANGELOG.md

@@ -261,7 +261,7 @@ put this to the `settings.json`
             }
         }
     ]
-}
+},
 
 "editor.semanticTokenColorCustomizations": {
     "rules": {

README.md

@@ -4,6 +4,7 @@
 import asyncio
 import os
 import sys
+import threading
 import weakref
 from abc import ABC, abstractmethod
 from collections import OrderedDict
@@ -473,67 +474,74 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
         self.parent_protocol.documents.did_create_uri.add(self._do_imports_changed)
         self.parent_protocol.documents.did_change.add(self.resource_document_changed)
         self._command_line_variables: Optional[List[VariableDefinition]] = None
+        self._command_line_variables_lock = Lock()
 
         self._python_path: Optional[List[str]] = None
+        self._python_path_lock = threading.RLock()
         self._environment: Optional[Mapping[str, str]] = None
+        self._environment_lock = threading.RLock()
 
         self._library_files_cache = AsyncSimpleLRUCache()
         self._resource_files_cache = AsyncSimpleLRUCache()
         self._variables_files_cache = AsyncSimpleLRUCache()
 
     @property
     def environment(self) -> Mapping[str, str]:
-        if self._environment is None:
-            self._environment = dict(os.environ)
+        with self._environment_lock:
+            if self._environment is None:
+                self._environment = dict(os.environ)
 
-            self._environment.update(self.config.env)
+                self._environment.update(self.config.env)
 
-        return self._environment
+            return self._environment
 
     @property
     def python_path(self) -> List[str]:
-        if self._python_path is None:
-            self._python_path = sys.path
+        with self._python_path_lock:
+            if self._python_path is None:
+                self._python_path = sys.path
 
-            file = Path(__file__).resolve()
-            top = file.parents[3]
-            for p in filter(lambda v: path_is_relative_to(v, top), sys.path.copy()):
-                self._python_path.remove(p)
+                file = Path(__file__).resolve()
+                top = file.parents[3]
+                for p in filter(lambda v: path_is_relative_to(v, top), sys.path.copy()):
+                    self._python_path.remove(p)
 
-        for p in self.config.python_path:
-            absolute_path = str(Path(p).absolute())
-            if absolute_path not in self._python_path:
-                self._python_path.insert(0, absolute_path)
+            for p in self.config.python_path:
+                absolute_path = str(Path(p).absolute())
+                if absolute_path not in self._python_path:
+                    self._python_path.insert(0, absolute_path)
 
-        return self._python_path or []
+            return self._python_path
 
     @_logger.call
     async def get_command_line_variables(self) -> List[VariableDefinition]:
         from robot.utils.text import split_args_from_name_or_path
 
-        if self._command_line_variables is None:
-            if self.config is None:
-                self._command_line_variables = []
-            else:
-                self._command_line_variables = [
-                    CommandLineVariableDefinition(0, 0, 0, 0, "", f"${{{k}}}", None, has_value=True, value=(v,))
-                    for k, v in self.config.variables.items()
-                ]
-                for variable_file in self.config.variable_files:
-                    name, args = split_args_from_name_or_path(variable_file)
-                    try:
-                        lib_doc = await self.get_libdoc_for_variables_import(
-                            name, tuple(args), str(self.folder.to_path()), self
-                        )
-                        if lib_doc is not None:
-                            self._command_line_variables += lib_doc.variables
-
-                    except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
-                        raise
-                    except BaseException as e:
-                        self._logger.exception(e)
-
-        return self._command_line_variables
+        async with self._command_line_variables_lock:
+            if self._command_line_variables is None:
+
+                if self.config is None:
+                    self._command_line_variables = []
+                else:
+                    self._command_line_variables = [
+                        CommandLineVariableDefinition(0, 0, 0, 0, "", f"${{{k}}}", None, has_value=True, value=(v,))
+                        for k, v in self.config.variables.items()
+                    ]
+                    for variable_file in self.config.variable_files:
+                        name, args = split_args_from_name_or_path(variable_file)
+                        try:
+                            lib_doc = await self.get_libdoc_for_variables_import(
+                                name, tuple(args), str(self.folder.to_path()), self
+                            )
+                            if lib_doc is not None:
+                                self._command_line_variables += lib_doc.variables
+
+                        except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
+                            raise
+                        except BaseException as e:
+                            self._logger.exception(e)
+
+            return self._command_line_variables
 
     @async_tasking_event
     async def libraries_changed(sender, libraries: List[LibraryDoc]) -> None:  # NOSONAR

poetry.lock

@@ -1029,9 +1029,13 @@ def resolve_robot_variables(
 
     if variables is not None:
 
-        vars = [_Variable(k, v) for k, v in variables.items() if v is not None]
+        vars = [_Variable(k, v) for k, v in variables.items() if v is not None and not isinstance(v, NativeValue)]
         result.set_from_variable_table(vars)
 
+        for k2, v2 in variables.items():
+            if isinstance(v2, NativeValue):
+                result[k2] = v2.value
+
         result.resolve_delayed()
 
     return result
@@ -1455,6 +1459,20 @@ def find_variables(
         )
 
 
+# @dataclass
+class NativeValue:
+    __slots__ = ["value"]
+
+    def __init__(self, value: Any) -> None:
+        self.value = value
+
+    def __repr__(self) -> str:
+        return repr(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
 def get_variables_doc(
     name: str,
     args: Optional[Tuple[Any, ...]] = None,
@@ -1513,9 +1531,19 @@ def import_variables(self, path: str, args: Optional[Tuple[Any, ...]] = None) ->
 
             vars: List[VariableDefinition] = [
                 ImportedVariableDefinition(
-                    1, 0, 1, 0, source or (module_spec.origin if module_spec is not None else None) or "", var[0], None
+                    1,
+                    0,
+                    1,
+                    0,
+                    source or (module_spec.origin if module_spec is not None else None) or "",
+                    name,
+                    None,
+                    value=NativeValue(value)
+                    if isinstance(value, (int, float, bool, str, set, tuple, dict, list))
+                    else None,
+                    has_value=isinstance(value, (int, float, bool, str, set, tuple, dict, list)),
                 )
-                for var in importer.import_variables(import_name, args)
+                for name, value in importer.import_variables(import_name, args)
             ]
 
             return VariablesDoc(

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -810,6 +810,7 @@ async def ensure_initialized(self) -> bool:
                             self._diagnostics = data_entry.diagnostics.copy()
                             self._import_entries = data_entry.import_entries.copy()
                         else:
+
                             variables = await self.get_resolvable_variables()
 
                             await self._import_default_libraries(variables)

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -2,6 +2,7 @@
 
 import ast
 import asyncio
+import reprlib
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -113,7 +114,7 @@ async def _hover_default(self, nodes: List[ast.AST], document: TextDocument, pos
 
                 if variable.has_value or variable.resolvable:
                     try:
-                        value = repr(
+                        value = reprlib.repr(
                             await namespace.imports_manager.resolve_variable(
                                 variable.name,
                                 str(document.uri.to_path().parent),

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -13,7 +13,7 @@
         }
     },
     "robotcode.languageServer.args": [
-        "--debugpy",
+        //"--debugpy",
         // "--log",
         // "--log-all",
         // "--log-level",

robotcode/language_server/robotframework/parts/hover.py

@@ -3,3 +3,8 @@ def dummy():  # type: ignore
 
 
 A_VAR_FROM_LIB = 1
+A_DICT_VAR_FROM_LIB = {1, 2, 3}
+A_LIST_VAR_FROM_LUB = [1, 2, 3, 4]
+A_MIXED_VAR_FROM_LIB = {1: "asd", 2: [1, 2, 3]}
+
+A_VERY_LONG_VAR_FROM_LIB = {str(i) for i in range(1000)}

tests/robotcode/language_server/robotframework/parts/data/.vscode/settings.json

@@ -1,3 +1,3 @@
 TEST_VAR: 1
-TEST_VAR2: 2
+TEST_VAR2: "hello"
 TEST_VAR3: [1, 2, 3, 4]