robotcode-robot 2.3.0__tar.gz → 2.4.0__tar.gz

{robotcode_robot-2.3.0 → robotcode_robot-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-robot
-Version: 2.3.0
+Version: 2.4.0
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode

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

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

{robotcode_robot-2.3.0 → robotcode_robot-2.4.0}/src/robotcode/robot/diagnostics/data_cache.py

@@ -12,6 +12,7 @@ _T = TypeVar("_T")
 class CacheSection(Enum):
     LIBRARY = "libdoc"
     VARIABLES = "variables"
+    RESOURCE = "resource"
 
 
 class DataCache(ABC):

{robotcode_robot-2.3.0 → robotcode_robot-2.4.0}/src/robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -46,6 +46,10 @@ _translation_table = str.maketrans("", "", "_- ")
 ROBOTCODE_MARKER = "robotcode:"
 
 
+def text_contains_diagnostic_modifier(text: str) -> bool:
+    return ROBOTCODE_MARKER in text
+
+
 class ModifiersVisitor(Visitor):
     def __init__(self) -> None:
         super().__init__()
@@ -181,7 +185,7 @@ class DiagnosticModifiersConfig:
 
 
 class DiagnosticsModifier:
-    def __init__(self, model: AST, config: Optional[DiagnosticModifiersConfig] = None) -> None:
+    def __init__(self, model: Optional[AST], config: Optional[DiagnosticModifiersConfig] = None) -> None:
         self.config = config or DiagnosticModifiersConfig()
 
         self.config.ignore = [i.translate(_translation_table).lower() for i in self.config.ignore]
@@ -190,12 +194,13 @@ class DiagnosticsModifier:
         self.config.information = [i.translate(_translation_table).lower() for i in self.config.information]
         self.config.hint = [i.translate(_translation_table).lower() for i in self.config.hint]
 
-        self.model = model
+        self._model = model
 
     @functools.cached_property
     def rules_and_codes(self) -> RulesAndCodes:
         visitor = ModifiersVisitor()
-        visitor.visit(self.model)
+        if self._model is not None:
+            visitor.visit(self._model)
         return visitor.rules_and_codes
 
     def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:

{robotcode_robot-2.3.0 → robotcode_robot-2.4.0}/src/robotcode/robot/diagnostics/document_cache_helper.py

@@ -8,7 +8,6 @@ from logging import CRITICAL
 from pathlib import Path
 from typing import (
     Any,
-    Callable,
     Iterable,
     Iterator,
     List,
@@ -26,7 +25,11 @@ from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.workspace import Workspace, WorkspaceFolder
-from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticModifiersConfig, DiagnosticsModifier
+from robotcode.robot.diagnostics.diagnostics_modifier import (
+    DiagnosticModifiersConfig,
+    DiagnosticsModifier,
+    text_contains_diagnostic_modifier,
+)
 
 from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
@@ -172,43 +175,16 @@ class DocumentsCacheHelper:
         return DocumentType.UNKNOWN
 
     def get_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
-        if data_only:
-            return self.__get_tokens_data_only(document)
-        return self.__get_tokens(document)
-
-    def __get_tokens_data_only(self, document: TextDocument) -> List[Token]:
-        document_type = self.get_document_type(document)
-        if document_type == DocumentType.INIT:
-            return self.get_init_tokens(document, True)
-        if document_type == DocumentType.GENERAL:
-            return self.get_general_tokens(document, True)
-        if document_type == DocumentType.RESOURCE:
-            return self.get_resource_tokens(document, True)
-
-        raise UnknownFileTypeError(str(document.uri))
-
-    def __get_tokens(self, document: TextDocument) -> List[Token]:
         document_type = self.get_document_type(document)
         if document_type == DocumentType.INIT:
-            return self.get_init_tokens(document)
+            return self.__get_init_tokens(document, data_only)
         if document_type == DocumentType.GENERAL:
-            return self.get_general_tokens(document)
+            return self.__get_general_tokens(document, data_only)
         if document_type == DocumentType.RESOURCE:
-            return self.get_resource_tokens(document)
+            return self.__get_resource_tokens(document, data_only)
 
         raise UnknownFileTypeError(str(document.uri))
 
-    def get_general_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
-        if document.version is None:
-            if data_only:
-                return self.__get_general_tokens_data_only(document)
-
-            return self.__get_general_tokens(document)
-
-        if data_only:
-            return document.get_cache(self.__get_general_tokens_data_only)
-        return document.get_cache(self.__get_general_tokens)
-
     def __internal_get_tokens(
         self,
         source: Any,
@@ -266,85 +242,20 @@ class DocumentsCacheHelper:
 
         return robot.api.get_init_tokens(source, data_only=data_only, tokenize_variables=tokenize_variables)
 
-    def __get_general_tokens_data_only(self, document: TextDocument) -> List[Token]:
+    def __get_general_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
         lang = self.get_languages_for_document(document)
+        with io.StringIO(document.text()) as content:
+            return [e for e in self.__internal_get_tokens(content, data_only, lang=lang)]
 
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_tokens(content, True, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
-
-    def __get_general_tokens(self, document: TextDocument) -> List[Token]:
+    def __get_resource_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
         lang = self.get_languages_for_document(document)
+        with io.StringIO(document.text()) as content:
+            return [e for e in self.__internal_get_resource_tokens(content, data_only, lang=lang)]
 
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_tokens(content, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
-
-    def __get_tokens_internal(self, document: TextDocument, get: Callable[[str], List[Token]]) -> List[Token]:
-        return get(document.text())
-
-    def get_resource_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
-        if document.version is None:
-            if data_only:
-                return self.__get_resource_tokens_data_only(document)
-
-            return self.__get_resource_tokens(document)
-
-        if data_only:
-            return document.get_cache(self.__get_resource_tokens_data_only)
-
-        return document.get_cache(self.__get_resource_tokens)
-
-    def __get_resource_tokens_data_only(self, document: TextDocument) -> List[Token]:
-        lang = self.get_languages_for_document(document)
-
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_resource_tokens(content, True, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
-
-    def __get_resource_tokens(self, document: TextDocument) -> List[Token]:
-        lang = self.get_languages_for_document(document)
-
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_resource_tokens(content, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
-
-    def get_init_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
-        if document.version is None:
-            if data_only:
-                return self.__get_init_tokens_data_only(document)
-
-            return self.__get_init_tokens(document)
-
-        if data_only:
-            return document.get_cache(self.__get_init_tokens_data_only)
-        return document.get_cache(self.__get_init_tokens)
-
-    def __get_init_tokens_data_only(self, document: TextDocument) -> List[Token]:
+    def __get_init_tokens(self, document: TextDocument, data_only: bool = False) -> List[Token]:
         lang = self.get_languages_for_document(document)
-
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_init_tokens(content, True, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
-
-    def __get_init_tokens(self, document: TextDocument) -> List[Token]:
-        lang = self.get_languages_for_document(document)
-
-        def get(text: str) -> List[Token]:
-            with io.StringIO(text) as content:
-                return [e for e in self.__internal_get_init_tokens(content, lang=lang)]
-
-        return self.__get_tokens_internal(document, get)
+        with io.StringIO(document.text()) as content:
+            return [e for e in self.__internal_get_init_tokens(content, data_only, lang=lang)]
 
     def get_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
         document_type = self.get_document_type(document)
@@ -383,59 +294,56 @@ class DocumentsCacheHelper:
     def get_general_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
         if document.version is None:
             if data_only:
-                return self.__get_general_model_data_only(document, self.get_general_tokens(document, True))
+                return self.__get_general_model_data_only(document)
 
-            return self.__get_general_model(document, self.get_general_tokens(document))
+            return self.__get_general_model(document)
 
         if data_only:
-            return document.get_cache(self.__get_general_model_data_only, self.get_general_tokens(document, True))
+            return document.get_cache(self.__get_general_model_data_only)
 
-        return document.get_cache(self.__get_general_model, self.get_general_tokens(document))
+        return document.get_cache(self.__get_general_model)
 
-    def __get_general_model_data_only(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.GENERAL)
+    def __get_general_model_data_only(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_general_tokens(document, True), DocumentType.GENERAL)
 
-    def __get_general_model(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.GENERAL)
+    def __get_general_model(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_general_tokens(document), DocumentType.GENERAL)
 
     def get_resource_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
         if document.version is None:
             if data_only:
-                return self.__get_resource_model_data_only(document, self.get_resource_tokens(document, True))
+                return self.__get_resource_model_data_only(document)
 
-            return self.__get_resource_model(document, self.get_resource_tokens(document))
+            return self.__get_resource_model(document)
 
         if data_only:
-            return document.get_cache(
-                self.__get_resource_model_data_only,
-                self.get_resource_tokens(document, True),
-            )
+            return document.get_cache(self.__get_resource_model_data_only)
 
-        return document.get_cache(self.__get_resource_model, self.get_resource_tokens(document))
+        return document.get_cache(self.__get_resource_model)
 
-    def __get_resource_model_data_only(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.RESOURCE)
+    def __get_resource_model_data_only(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_resource_tokens(document, True), DocumentType.RESOURCE)
 
-    def __get_resource_model(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.RESOURCE)
+    def __get_resource_model(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_resource_tokens(document), DocumentType.RESOURCE)
 
     def get_init_model(self, document: TextDocument, data_only: bool = True) -> ast.AST:
         if document.version is None:
             if data_only:
-                return self.__get_init_model_data_only(document, self.get_init_tokens(document, True))
+                return self.__get_init_model_data_only(document)
 
-            return self.__get_init_model(document, self.get_init_tokens(document))
+            return self.__get_init_model(document)
 
         if data_only:
-            return document.get_cache(self.__get_init_model_data_only, self.get_init_tokens(document, True))
+            return document.get_cache(self.__get_init_model_data_only)
 
-        return document.get_cache(self.__get_init_model, self.get_init_tokens(document))
+        return document.get_cache(self.__get_init_model)
 
-    def __get_init_model_data_only(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.INIT)
+    def __get_init_model_data_only(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_init_tokens(document, True), DocumentType.INIT)
 
-    def __get_init_model(self, document: TextDocument, tokens: Iterable[Any]) -> ast.AST:
-        return self.__get_model(document, tokens, DocumentType.INIT)
+    def __get_init_model(self, document: TextDocument) -> ast.AST:
+        return self.__get_model(document, self.__get_init_tokens(document), DocumentType.INIT)
 
     def get_namespace(self, document: TextDocument) -> Namespace:
         document_type = self.get_document_type(document)
@@ -627,8 +535,16 @@ class DocumentsCacheHelper:
 
     def __get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
         modifiers_config = self.workspace.get_configuration(AnalysisDiagnosticModifiersConfig, document.uri)
+
+        has_modifier = text_contains_diagnostic_modifier(document.text())
+
+        if has_modifier:
+            self._logger.debug(
+                lambda: f"Document {document.uri} contains diagnostic modifier comment, analyzing model for it"
+            )
+
         return DiagnosticsModifier(
-            self.get_model(document, False),
+            self.get_model(document, False) if has_modifier else None,
             DiagnosticModifiersConfig(
                 ignore=self.analysis_config.modifiers.ignore + modifiers_config.ignore,
                 error=self.analysis_config.modifiers.error + modifiers_config.error,