robotcode-robot 0.76.0__tar.gz → 0.76.1__tar.gz

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotcode-robot
-Version: 0.76.0
+Version: 0.76.1
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://github.com/sponsors/d-biehl
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Requires-Dist: platformdirs<4.2.0,>=3.2.0
-Requires-Dist: robotcode-core==0.76.0
+Requires-Dist: robotcode-core==0.76.1
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
   "robotframework>=4.1.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=3.2.0,<4.2.0",
-  "robotcode-core==0.76.0",
+  "robotcode-core==0.76.1",
 ]
 dynamic = ["version"]
 

robotcode_robot-0.76.1/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.76.1"

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/src/robotcode/robot/diagnostics/document_cache_helper.py

@@ -22,7 +22,6 @@ from robot.parsing.lexer.tokens import Token
 from robotcode.core.documents_manager import DocumentsManager
 from robotcode.core.event import event
 from robotcode.core.filewatcher import FileWatcherManagerBase
-from robotcode.core.language import language_id_filter
 from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
@@ -32,6 +31,7 @@ from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
 from ..utils.stubs import Languages
 from .imports_manager import ImportsManager
+from .library_doc import LibraryDoc
 from .namespace import DocumentType, Namespace
 from .workspace_config import AnalysisRobotConfig, CacheConfig, RobotConfig
 
@@ -421,15 +421,21 @@ class DocumentsCacheHelper:
     def __get_general_namespace(self, document: TextDocument) -> Namespace:
         return self.__get_namespace_for_document_type(document, DocumentType.GENERAL)
 
+    @event
+    def namespace_initialized(sender, namespace: Namespace) -> None: ...
+
     @event
     def namespace_invalidated(sender, namespace: Namespace) -> None: ...
 
     def __invalidate_namespace(self, sender: Namespace) -> None:
         document = sender.document
         if document is not None:
-            document.invalidate_cache()
+            document.remove_cache_entry(self.__get_general_namespace)
+            document.remove_cache_entry(self.__get_init_namespace)
+            document.remove_cache_entry(self.__get_resource_namespace)
+            document.remove_cache_entry(self.__get_namespace)
 
-            self.namespace_invalidated(self, sender, callback_filter=language_id_filter(document))
+            self.namespace_invalidated(self, sender)
 
     def __namespace_initialized(self, sender: Namespace) -> None:
         if sender.document is not None:
@@ -437,6 +443,7 @@ class DocumentsCacheHelper:
                 lambda: f"Save initialized Namespace: {sender.document.uri if sender.document else None}"
             )
             sender.document.set_data(self.INITIALIZED_NAMESPACE, sender)
+            self.namespace_initialized(self, sender)
 
     def get_initialized_namespace(self, document: TextDocument) -> Namespace:
         result: Optional[Namespace] = document.get_data(self.INITIALIZED_NAMESPACE)
@@ -445,6 +452,11 @@ class DocumentsCacheHelper:
             result = self.get_namespace(document)
         return result
 
+    def get_only_initialized_namespace(self, document: TextDocument) -> Optional[Namespace]:
+        result: Optional[Namespace] = document.get_data(self.INITIALIZED_NAMESPACE)
+
+        return result
+
     def __get_namespace_for_document_type(
         self, document: TextDocument, document_type: Optional[DocumentType]
     ) -> Namespace:
@@ -495,7 +507,7 @@ class DocumentsCacheHelper:
         ]
 
         analysis_config = self.workspace.get_configuration(AnalysisRobotConfig, root_uri)
-        return ImportsManager(
+        result = ImportsManager(
             self.documents_manager,
             self.file_watcher_manager,
             self,
@@ -510,6 +522,30 @@ class DocumentsCacheHelper:
             cache_base_path,
         )
 
+        result.libraries_changed.add(self._on_libraries_changed)
+        result.resources_changed.add(self._on_resources_changed)
+        result.variables_changed.add(self._on_variables_changed)
+
+        return result
+
+    @event
+    def libraries_changed(sender, libraries: List[LibraryDoc]) -> None: ...
+
+    @event
+    def resources_changed(sender, resources: List[LibraryDoc]) -> None: ...
+
+    @event
+    def variables_changed(sender, variables: List[LibraryDoc]) -> None: ...
+
+    def _on_libraries_changed(self, sender: ImportsManager, libraries: List[LibraryDoc]) -> None:
+        self.libraries_changed(self, libraries)
+
+    def _on_resources_changed(self, sender: ImportsManager, resources: List[LibraryDoc]) -> None:
+        self.resources_changed(self, resources)
+
+    def _on_variables_changed(self, sender: ImportsManager, variables: List[LibraryDoc]) -> None:
+        self.variables_changed(self, variables)
+
     def default_imports_manager(self) -> ImportsManager:
         with self._imports_managers_lock:
             if self._default_imports_manager is None:

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/src/robotcode/robot/diagnostics/entities.py

@@ -195,11 +195,10 @@ class VariableDefinition(SourceEntity):
     value: Any = field(default=None, compare=False)
     value_is_native: bool = field(default=False, compare=False)
 
-    @property
-    def matcher(self) -> VariableMatcher:
-        if not hasattr(self, "__matcher"):
-            self.__matcher = VariableMatcher(self.name)
-        return self.__matcher
+    matcher: VariableMatcher = field(init=False, compare=False)
+
+    def __post_init__(self) -> None:
+        self.matcher = VariableMatcher(self.name)
 
     @single_call
     def __hash__(self) -> int:

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/src/robotcode/robot/diagnostics/imports_manager.py

@@ -503,8 +503,8 @@ class ImportsManager:
         super().__init__()
 
         self.documents_manager = documents_manager
-        self.documents_manager.did_create_uri.add(self.possible_imports_modified)
-        self.documents_manager.did_change.add(self.possible_resource_document_modified)
+        self.documents_manager.did_create_uri.add(self._on_possible_imports_modified)
+        self.documents_manager.did_change.add(self._on_possible_resource_document_modified)
 
         self.file_watcher_manager: FileWatcherManagerBase = (
             file_watcher_manager if file_watcher_manager is not None else FileWatcherManagerDummy()
@@ -685,12 +685,15 @@ class ImportsManager:
     @event
     def imports_changed(sender, uri: DocumentUri) -> None: ...
 
-    def possible_imports_modified(self, sender: Any, uri: DocumentUri) -> None:
+    def _on_possible_imports_modified(self, sender: Any, uri: DocumentUri) -> None:
         # TODO: do we really need this?
         self.imports_changed(self, uri)
 
     @language_id("robotframework")
-    def possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
+    def _on_possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
+        run_as_task(self.__on_possible_resource_document_modified, sender, document)
+
+    def __on_possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
         with self._resource_document_changed_timer_lock:
             if document in self._resource_document_changed_documents:
                 return
@@ -714,7 +717,7 @@ class ImportsManager:
             self._resource_document_changed_documents = set()
 
         for document in documents:
-            run_as_task(self.__resource_document_changed, document).result()
+            self.__resource_document_changed(document)
 
     def __resource_document_changed(self, document: TextDocument) -> None:
         resource_changed: List[LibraryDoc] = []

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/src/robotcode/robot/diagnostics/model_helper.py

@@ -290,7 +290,7 @@ class ModelHelper:
                                     sub_token.lineno,
                                     sub_token.end_col_offset,
                                     namespace.source,
-                                    tokval,
+                                    f"${{{tokval}}}",
                                     sub_token,
                                 ),
                             )

{robotcode_robot-0.76.0 → robotcode_robot-0.76.1}/src/robotcode/robot/diagnostics/namespace.py

@@ -584,6 +584,9 @@ class Namespace:
         self._global_variables: Optional[List[VariableDefinition]] = None
         self._global_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
 
+        self._suite_variables: Optional[Dict[str, Any]] = None
+        self._suite_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
+
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = {}
         self._variable_references: Dict[VariableDefinition, Set[Location]] = {}
@@ -600,10 +603,10 @@ class Namespace:
 
         self._finder: Optional[KeywordFinder] = None
 
-        self.imports_manager.imports_changed.add(self.imports_changed)
-        self.imports_manager.libraries_changed.add(self.libraries_changed)
-        self.imports_manager.resources_changed.add(self.resources_changed)
-        self.imports_manager.variables_changed.add(self.variables_changed)
+        self.imports_manager.imports_changed.add(self._on_imports_changed)
+        self.imports_manager.libraries_changed.add(self._on_libraries_changed)
+        self.imports_manager.resources_changed.add(self._on_resources_changed)
+        self.imports_manager.variables_changed.add(self._on_variables_changed)
 
         self._in_initialize = False
 
@@ -618,6 +621,15 @@ class Namespace:
     @event
     def has_analysed(sender) -> None: ...
 
+    @event
+    def library_import_changed(sender) -> None: ...
+
+    @event
+    def resource_import_changed(sender) -> None: ...
+
+    @event
+    def variables_import_changed(sender) -> None: ...
+
     @property
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
@@ -629,12 +641,12 @@ class Namespace:
 
         return self._search_order
 
-    def imports_changed(self, sender: Any, uri: DocumentUri) -> None:
+    def _on_imports_changed(self, sender: Any, uri: DocumentUri) -> None:
         # TODO: optimise this by checking our imports
         self.invalidate()
 
     @_logger.call
-    def libraries_changed(self, sender: Any, libraries: List[LibraryDoc]) -> None:
+    def _on_libraries_changed(self, sender: Any, libraries: List[LibraryDoc]) -> None:
         if not self.initialized or self.invalid:
             return
 
@@ -649,7 +661,7 @@ class Namespace:
             self.invalidate()
 
     @_logger.call
-    def resources_changed(self, sender: Any, resources: List[LibraryDoc]) -> None:
+    def _on_resources_changed(self, sender: Any, resources: List[LibraryDoc]) -> None:
         if not self.initialized or self.invalid:
             return
 
@@ -664,7 +676,7 @@ class Namespace:
             self.invalidate()
 
     @_logger.call
-    def variables_changed(self, sender: Any, variables: List[LibraryDoc]) -> None:
+    def _on_variables_changed(self, sender: Any, variables: List[LibraryDoc]) -> None:
         if not self.initialized or self.invalid:
             return
 
@@ -684,19 +696,20 @@ class Namespace:
 
     def _invalidate(self) -> None:
         self._invalid = True
-        self.imports_manager.imports_changed.remove(self.imports_changed)
-        self.imports_manager.libraries_changed.remove(self.libraries_changed)
-        self.imports_manager.resources_changed.remove(self.resources_changed)
-        self.imports_manager.variables_changed.remove(self.variables_changed)
+        self.imports_manager.imports_changed.remove(self._on_imports_changed)
+        self.imports_manager.libraries_changed.remove(self._on_libraries_changed)
+        self.imports_manager.resources_changed.remove(self._on_resources_changed)
+        self.imports_manager.variables_changed.remove(self._on_variables_changed)
 
     @_logger.call
-    def invalidate(self) -> None:
+    def invalidate(self) -> bool:
         with self._initialize_lock:
             if self._invalid:
-                return
+                return False
 
             self._invalidate()
         self.has_invalidated(self)
+        return True
 
     @_logger.call
     def get_diagnostics(self) -> List[Diagnostic]:
@@ -803,7 +816,7 @@ class Namespace:
 
                     imports = self.get_imports()
 
-                    variables = self.get_resolvable_variables()
+                    variables = self.get_suite_variables()
 
                     self._import_default_libraries(variables)
                     self._import_imports(
@@ -868,8 +881,9 @@ class Namespace:
         return self.imports_manager.get_command_line_variables()
 
     def _reset_global_variables(self) -> None:
-        with self._global_variables_lock:
+        with self._global_variables_lock, self._suite_variables_lock:
             self._global_variables = None
+            self._suite_variables = None
 
     def get_global_variables(self) -> List[VariableDefinition]:
         with self._global_variables_lock:
@@ -894,13 +908,16 @@ class Namespace:
     ) -> Iterator[Tuple[VariableMatcher, VariableDefinition]]:
         yielded: Dict[VariableMatcher, VariableDefinition] = {}
 
-        test_or_keyword_nodes = list(
-            itertools.dropwhile(
-                lambda v: not isinstance(v, (TestCase, Keyword)),
-                nodes if nodes else [],
+        test_or_keyword = None
+
+        if nodes:
+            test_or_keyword_nodes = list(
+                itertools.dropwhile(
+                    lambda v: not isinstance(v, (TestCase, Keyword)),
+                    nodes if nodes else [],
+                )
             )
-        )
-        test_or_keyword = test_or_keyword_nodes[0] if test_or_keyword_nodes else None
+            test_or_keyword = test_or_keyword_nodes[0] if test_or_keyword_nodes else None
 
         for var in chain(
             *[
@@ -928,6 +945,31 @@ class Namespace:
 
                 yield var.matcher, var
 
+    def get_suite_variables(
+        self,
+        nodes: Optional[List[ast.AST]] = None,
+        position: Optional[Position] = None,
+    ) -> Dict[str, Any]:
+        if nodes:
+            return {
+                v.name: v.value
+                for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
+                if v.has_value
+            }
+        with self._suite_variables_lock:
+            vars = {}
+
+            def check_var(var: VariableDefinition) -> bool:
+                if var.matcher in vars:
+                    return False
+                vars[var.matcher] = var
+
+                return var.has_value
+
+            self._suite_variables = {v.name: v.value for v in filter(check_var, self.get_global_variables())}
+
+        return self._suite_variables
+
     def get_resolvable_variables(
         self,
         nodes: Optional[List[ast.AST]] = None,
@@ -1200,7 +1242,7 @@ class Namespace:
         try:
             for imp in imports:
                 if variables is None:
-                    variables = self.get_resolvable_variables()
+                    variables = self.get_suite_variables()
 
                 entry = self._import(
                     imp,
@@ -1222,7 +1264,7 @@ class Namespace:
                         if already_imported_resources is None and entry.library_doc.source != self.source:
                             self._resources[entry.import_name] = entry
                             if entry.variables:
-                                variables = self.get_resolvable_variables()
+                                variables = self.get_suite_variables()
 
                             try:
                                 variables = self._import_imports(
@@ -1296,7 +1338,7 @@ class Namespace:
                         ):
                             self._variables[entry.library_doc.source_or_origin] = entry
                             if entry.variables:
-                                variables = self.get_resolvable_variables()
+                                variables = self.get_suite_variables()
                         elif top_level and already_imported_variables and already_imported_variables.library_doc.source:
                             self.append_diagnostics(
                                 range=entry.import_range,
@@ -1416,7 +1458,7 @@ class Namespace:
         self._logger.debug(lambda: f"start import default libraries for document {self.document}")
         try:
             if variables is None:
-                variables = self.get_resolvable_variables()
+                variables = self.get_suite_variables()
 
             for library in DEFAULT_LIBRARIES:
                 e = _import_lib(library, variables)
@@ -1438,7 +1480,7 @@ class Namespace:
         variables: Optional[Dict[str, Any]] = None,
     ) -> LibraryEntry:
         if variables is None:
-            variables = self.get_resolvable_variables()
+            variables = self.get_suite_variables()
 
         library_doc = self.imports_manager.get_libdoc_for_library_import(
             name,
@@ -1480,7 +1522,7 @@ class Namespace:
         variables: Optional[Dict[str, Any]] = None,
     ) -> ResourceEntry:
         if variables is None:
-            variables = self.get_resolvable_variables()
+            variables = self.get_suite_variables()
 
         (namespace, library_doc) = self.imports_manager.get_namespace_and_libdoc_for_resource_import(
             name, base_dir, sentinel=self, variables=variables
@@ -1517,7 +1559,7 @@ class Namespace:
         variables: Optional[Dict[str, Any]] = None,
     ) -> VariablesEntry:
         if variables is None:
-            variables = self.get_resolvable_variables()
+            variables = self.get_suite_variables()
 
         library_doc = self.imports_manager.get_libdoc_for_variables_import(
             name,
@@ -1630,6 +1672,10 @@ class Namespace:
             )
         )
 
+    def is_analyzed(self) -> bool:
+        with self._analyze_lock:
+            return self._analyzed
+
     @_logger.call(condition=lambda self: not self._analyzed)
     def analyze(self) -> None:
         import time

robotcode_robot-0.76.0/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.76.0"