robotcode-robot 0.83.3__tar.gz → 0.85.0__tar.gz

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/.gitignore

@@ -293,3 +293,6 @@ report.html
 .ruff_cache/
 
 bundled/libs
+
+# robotframework
+results/

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.83.3
+Version: 0.85.0
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -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.83.3
+Requires-Dist: robotcode-core==0.85.0
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/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.83.3",
+  "robotcode-core==0.85.0",
 ]
 dynamic = ["version"]
 

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

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

robotcode_robot-0.85.0/src/robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -0,0 +1,201 @@
+import functools
+import re as re
+from ast import AST
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set, Union
+
+from robot.parsing.lexer.tokens import Token
+from robot.parsing.model.blocks import Block, File
+from robot.parsing.model.statements import Comment, Statement
+from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity
+
+from ..utils.visitor import Visitor
+
+ACTIONS = ["ignore", "error", "warn", "information", "hint", "reset"]
+
+ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
+
+
+@dataclass
+class RulesAndCodes:
+    codes: Dict[Union[str, int], Set[int]]
+    actions: Dict[int, Dict[Union[str, int], str]]
+
+
+_translation_table = str.maketrans("", "", "_- ")
+
+ROBOTCODE_MARKER = "robotcode:"
+
+
+class DisablersVisitor(Visitor):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._file_lineno = 0
+        self._file_end_lineno = 0
+        self.current_block: Optional[Block] = None
+        self.rules_and_codes: RulesAndCodes = RulesAndCodes(defaultdict(set), defaultdict(dict))
+
+    @property
+    def file_lineno(self) -> int:
+        return self._file_lineno
+
+    @property
+    def file_end_lineno(self) -> int:
+        return self._file_end_lineno
+
+    def visit_File(self, node: File) -> None:  # noqa: N802
+        self._file_lineno = node.lineno - 1
+        self._file_end_lineno = node.end_lineno - 1
+
+        self.generic_visit(node)
+
+    def visit_Comment(self, node: Comment) -> None:  # noqa: N802
+        self._handle_comment(node)
+
+        self.generic_visit(node)
+
+    def visit_Block(self, node: Block) -> None:  # noqa: N802
+        self.current_block = node
+        self.generic_visit(node)
+
+    def visit_Statement(self, node: Statement) -> None:  # noqa: N802
+        self._handle_statement_comments(node)
+        self.generic_visit(node)
+
+    def _parse_robotcode_disabler(self, comment: str) -> Dict[str, List[str]]:
+        result: Dict[str, List[str]] = {}
+
+        comment = comment.strip()
+        m = ROBOTCODE_ACTION_AND_CODES_PATTERN.match(comment)
+        if m is None:
+            return result
+
+        for m in ROBOTCODE_ACTION_AND_CODES_PATTERN.finditer(comment):
+            action = m.group("action")
+            messages = m.group("codes")
+            result[action] = (
+                [m.strip().translate(_translation_table).lower() for m in messages.split(",")]
+                if messages is not None
+                else ["*"]
+            )
+
+        return result
+
+    def _handle_statement_comments(self, node: Statement) -> None:
+        first_comment = True
+        has_marker = False
+
+        for token in node.get_tokens(Token.COMMENT):
+            value = token.value.strip()
+            if first_comment and value.startswith("#"):
+                value = value[1:].strip()
+                first_comment = False
+
+            if not value:
+                continue
+
+            if not has_marker and value.startswith(ROBOTCODE_MARKER):
+                has_marker = True
+                value = value[10:]
+
+            if not value:
+                continue
+
+            if has_marker:
+                actions = self._parse_robotcode_disabler(value)
+
+                if not actions:
+                    break
+
+                for action, codes in actions.items():
+                    for code in codes:
+                        self.rules_and_codes.codes[code].add(token.lineno - 1)
+                        self.rules_and_codes.actions[token.lineno - 1][code] = action
+
+    def _handle_comment(self, node: Comment) -> None:
+        first_comment = True
+        has_marker = False
+
+        start_lineno = node.lineno - 1
+        end_lineno = self.file_end_lineno
+
+        if node.tokens[0].type == Token.SEPARATOR and self.current_block is not None:
+            end_lineno = self.current_block.end_lineno - 1
+        for token in node.get_tokens(Token.COMMENT):
+            value = token.value.strip()
+            if first_comment and value.startswith("#"):
+                value = value[1:].strip()
+                first_comment = False
+
+            if not value:
+                continue
+
+            if not has_marker and value.startswith(ROBOTCODE_MARKER):
+                has_marker = True
+                value = value[10:]
+
+            if not value:
+                continue
+
+            if has_marker:
+                actions = self._parse_robotcode_disabler(value)
+
+                if not actions:
+                    break
+
+                for action, codes in actions.items():
+                    for code in codes:
+                        self.rules_and_codes.codes[code].update(range(start_lineno, end_lineno + 1))
+                        for i in range(start_lineno, end_lineno + 1):
+                            self.rules_and_codes.actions[i][code] = action
+
+
+class DiagnosticsModifier:
+    def __init__(self, model: AST) -> None:
+        self.model = model
+
+    @functools.cached_property
+    def rules_and_codes(self) -> RulesAndCodes:
+        visitor = DisablersVisitor()
+        visitor.visit(self.model)
+        return visitor.rules_and_codes
+
+    def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
+        if diagnostic.code is not None:
+            code = (
+                str(diagnostic.code).translate(_translation_table).lower()
+                if diagnostic.code is not None
+                else "unknowncode"
+            )
+
+            lines = self.rules_and_codes.codes.get(code)
+
+            if lines is None or lines is not None and diagnostic.range.start.line not in lines:
+                code = "*"
+                lines = self.rules_and_codes.codes.get(code)
+
+            if lines is not None and diagnostic.range.start.line in lines:
+                actions = self.rules_and_codes.actions.get(diagnostic.range.start.line)
+                if actions is not None:
+                    action = actions.get(code)
+                    if action is not None:
+                        if action == "ignore":
+                            return None
+                        if action == "reset":
+                            pass  # do nothing
+                        elif action == "error":
+                            diagnostic.severity = DiagnosticSeverity.ERROR
+                        elif action == "warn":
+                            diagnostic.severity = DiagnosticSeverity.WARNING
+                        elif action == "information":
+                            diagnostic.severity = DiagnosticSeverity.INFORMATION
+                        elif action == "hint":
+                            diagnostic.severity = DiagnosticSeverity.HINT
+
+        return diagnostic
+
+    def modify_diagnostics(self, diagnostics: List[Diagnostic]) -> List[Diagnostic]:
+        return [d for d in map(self.modify_diagnostic, diagnostics) if d is not None]

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/document_cache_helper.py

@@ -26,6 +26,7 @@ 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 DiagnosticsModifier
 
 from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
@@ -453,9 +454,7 @@ class DocumentsCacheHelper:
         return result
 
     def get_only_initialized_namespace(self, document: TextDocument) -> Optional[Namespace]:
-        result: Optional[Namespace] = document.get_data(self.INITIALIZED_NAMESPACE)
-
-        return result
+        return cast(Optional[Namespace], document.get_data(self.INITIALIZED_NAMESPACE))
 
     def __get_namespace_for_document_type(
         self, document: TextDocument, document_type: Optional[DocumentType]
@@ -579,3 +578,9 @@ class DocumentsCacheHelper:
     def calc_cache_path(self, folder_uri: Uri) -> Path:
         # TODO: cache path should be configurable, save cache in vscode workspace folder or in robotcode cache folder
         return folder_uri.to_path()
+
+    def get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
+        return document.get_cache(self.__get_diagnostic_modifier)
+
+    def __get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
+        return DiagnosticsModifier(self.get_model(document, False))

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/entities.py

@@ -12,7 +12,9 @@ from typing import (
 )
 
 from robot.parsing.lexer.tokens import Token
+from robot.variables.search import search_variable
 from robotcode.core.lsp.types import Position, Range
+from robotcode.robot.utils.match import normalize
 
 from ..utils.ast import range_from_token
 
@@ -131,9 +133,6 @@ class InvalidVariableError(Exception):
 
 class VariableMatcher:
     def __init__(self, name: str) -> None:
-        from robot.variables.search import search_variable
-        from robotcode.robot.utils.match import normalize
-
         self.name = name
 
         match = search_variable(name, "$@&%", ignore_errors=True)
@@ -146,9 +145,6 @@ class VariableMatcher:
         self.normalized_name = str(normalize(self.base))
 
     def __eq__(self, o: object) -> bool:
-        from robot.utils.normalizing import normalize
-        from robot.variables.search import search_variable
-
         if isinstance(o, VariableMatcher):
             return o.normalized_name == self.normalized_name
 

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/errors.py

@@ -31,3 +31,5 @@ class Error:
     DEPRECATED_FORCE_TAG = "DeprecatedForceTag"
     IMPORT_REQUIRES_VALUE = "ImportRequiresValue"
     KEYWORD_ERROR = "KeywordError"
+    MULTIPLE_KEYWORDS = "MultipleKeywords"
+    CONFLICTING_LIBRARY_KEYWORDS = "ConflictingLibraryKeywords"

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/library_doc.py

@@ -86,10 +86,10 @@ from robotcode.robot.utils.match import normalize, normalize_namespace
 from robotcode.robot.utils.stubs import HasError, HasErrors
 
 if get_robot_version() < (7, 0):
-    from robot.running.handlers import _PythonHandler, _PythonInitHandler
-    from robot.running.model import ResourceFile
-    from robot.running.usererrorhandler import UserErrorHandler
-    from robot.running.userkeyword import UserLibrary
+    from robot.running.handlers import _PythonHandler, _PythonInitHandler  # pyright: ignore[reportMissingImports]
+    from robot.running.model import ResourceFile  # pyright: ignore[reportMissingImports]
+    from robot.running.usererrorhandler import UserErrorHandler  # pyright: ignore[reportMissingImports]
+    from robot.running.userkeyword import UserLibrary  # pyright: ignore[reportMissingImports]
 
     robot_notset = ArgInfo.NOTSET
 
@@ -1960,7 +1960,7 @@ def get_library_doc(
                             return_type=(
                                 (
                                     str(kw[1].args.return_type)
-                                    if kw[1].args.return_type is not None and kw[1].args.return_type != type(None)
+                                    if kw[1].args.return_type is not None and kw[1].args.return_type is not type(None)
                                     else None
                                 )
                                 if get_robot_version() >= (7, 0)
@@ -2636,7 +2636,7 @@ def get_model_doc(
                     message=error,
                     type_name="ModelError",
                     source=source,
-                    line_no=node.lineno,
+                    line_no=node.lineno,  # type: ignore
                 )
             )
         if append_model_errors:
@@ -2648,7 +2648,7 @@ def get_model_doc(
                             message=e,
                             type_name="ModelError",
                             source=source,
-                            line_no=node.lineno,
+                            line_no=node.lineno,  # type: ignore
                         )
                     )
 

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/namespace.py

@@ -1,7 +1,6 @@
 import ast
 import enum
 import itertools
-import re
 import time
 import weakref
 from collections import OrderedDict, defaultdict
@@ -97,9 +96,6 @@ from .library_doc import (
     resolve_robot_variables,
 )
 
-EXTRACT_COMMENT_PATTERN = re.compile(r".*(?:^ *|\t+| {2,})#(?P<comment>.*)$")
-ROBOTCODE_PATTERN = re.compile(r"(?P<marker>\brobotcode\b)\s*:\s*(?P<rule>\b\w+\b)")
-
 
 class DiagnosticsError(Exception):
     pass
@@ -454,7 +450,7 @@ class BlockVariableVisitor(OnlyArgumentsVisitor):
                     source=self.namespace.source,
                 )
 
-                if var_name not in self._results or type(self._results[var_name]) != type(var):
+                if var_name not in self._results or type(self._results[var_name]) is not type(var):
                     if isinstance(var, LocalVariableDefinition) or not any(
                         l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
                     ):
@@ -542,7 +538,7 @@ class BlockVariableVisitor(OnlyArgumentsVisitor):
                 source=self.namespace.source,
             )
 
-            if var_name not in self._results or type(self._results[var_name]) != type(var):
+            if var_name not in self._results or type(self._results[var_name]) is type(var):
                 if isinstance(var, LocalVariableDefinition) or not any(
                     l for l in self.namespace.get_global_variables() if l.matcher == var.matcher
                 ):
@@ -1803,8 +1799,6 @@ class Namespace:
         related_information: Optional[List[DiagnosticRelatedInformation]] = None,
         data: Optional[Any] = None,
     ) -> None:
-        if self._should_ignore(range):
-            return
 
         self._diagnostics.append(
             Diagnostic(
@@ -1840,12 +1834,7 @@ class Namespace:
                 start_time = time.monotonic()
 
                 try:
-                    result = NamespaceAnalyzer(
-                        self.model,
-                        self,
-                        self.create_finder(),
-                        self.get_ignored_lines(self.document) if self.document is not None else [],
-                    ).run()
+                    result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
 
                     self._diagnostics += result.diagnostics
                     self._keyword_references = result.keyword_references
@@ -1916,42 +1905,6 @@ class Namespace:
             handle_bdd_style=handle_bdd_style,
         )
 
-    @classmethod
-    def get_ignored_lines(cls, document: TextDocument) -> List[int]:
-        return document.get_cache(cls.__get_ignored_lines)
-
-    @staticmethod
-    def __get_ignored_lines(document: TextDocument) -> List[int]:
-        result = []
-        lines = document.get_lines()
-        for line_no, line in enumerate(lines):
-            comment = EXTRACT_COMMENT_PATTERN.match(line)
-            if comment and comment.group("comment"):
-                for match in ROBOTCODE_PATTERN.finditer(comment.group("comment")):
-                    if match.group("rule") == "ignore":
-                        result.append(line_no)
-
-        return result
-
-    @classmethod
-    def should_ignore(cls, document: Optional[TextDocument], range: Range) -> bool:
-        return cls.__should_ignore(
-            cls.get_ignored_lines(document) if document is not None else [],
-            range,
-        )
-
-    def _should_ignore(self, range: Range) -> bool:
-        if self._ignored_lines is None:
-            self._ignored_lines = self.get_ignored_lines(self.document) if self.document is not None else []
-
-        return self.__should_ignore(self._ignored_lines, range)
-
-    @staticmethod
-    def __should_ignore(lines: List[int], range: Range) -> bool:
-        import builtins
-
-        return any(line_no in lines for line_no in builtins.range(range.start.line, range.end.line + 1))
-
 
 class DiagnosticsEntry(NamedTuple):
     message: str
@@ -2083,7 +2036,7 @@ class KeywordFinder:
                         DiagnosticsEntry(
                             self._create_multiple_keywords_found_message(name, found, implicit=False),
                             DiagnosticSeverity.ERROR,
-                            Error.KEYWORD_ERROR,
+                            Error.MULTIPLE_KEYWORDS,
                         )
                     )
                     raise CancelSearchError
@@ -2118,7 +2071,7 @@ class KeywordFinder:
                 DiagnosticsEntry(
                     self._create_multiple_keywords_found_message(name, found, implicit=False),
                     DiagnosticSeverity.ERROR,
-                    Error.KEYWORD_ERROR,
+                    Error.MULTIPLE_KEYWORDS,
                 )
             )
             raise CancelSearchError
@@ -2266,7 +2219,7 @@ class KeywordFinder:
             DiagnosticsEntry(
                 self._create_multiple_keywords_found_message(name, found),
                 DiagnosticSeverity.ERROR,
-                Error.KEYWORD_ERROR,
+                Error.MULTIPLE_KEYWORDS,
             )
         )
         raise CancelSearchError
@@ -2320,7 +2273,7 @@ class KeywordFinder:
             DiagnosticsEntry(
                 self._create_multiple_keywords_found_message(name, found),
                 DiagnosticSeverity.ERROR,
-                Error.KEYWORD_ERROR,
+                Error.MULTIPLE_KEYWORDS,
             )
         )
         raise CancelSearchError
@@ -2342,7 +2295,7 @@ class KeywordFinder:
             DiagnosticsEntry(
                 self._create_custom_and_standard_keyword_conflict_warning_message(custom, standard),
                 DiagnosticSeverity.WARNING,
-                Error.KEYWORD_ERROR,
+                Error.CONFLICTING_LIBRARY_KEYWORDS,
             )
         )
 

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -117,14 +117,12 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
         model: ast.AST,
         namespace: Namespace,
         finder: KeywordFinder,
-        ignored_lines: List[int],
     ) -> None:
         super().__init__()
 
         self.model = model
         self.namespace = namespace
         self.finder = finder
-        self._ignored_lines = ignored_lines
 
         self.current_testcase_or_keyword_name: Optional[str] = None
         self.test_template: Optional[TestTemplate] = None
@@ -261,8 +259,6 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
                     )
                 )
             )
-            # r.start.character = 0
-            # r.end.character = 0
 
             var_def = self.namespace.find_variable(
                 name,
@@ -450,15 +446,6 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
         finally:
             self.node_stack = self.node_stack[:-1]
 
-    def _should_ignore(self, range: Range) -> bool:
-        import builtins
-
-        for line_no in builtins.range(range.start.line, range.end.line + 1):
-            if line_no in self._ignored_lines:
-                return True
-
-        return False
-
     def append_diagnostics(
         self,
         range: Range,
@@ -471,8 +458,6 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
         related_information: Optional[List[DiagnosticRelatedInformation]] = None,
         data: Optional[Any] = None,
     ) -> None:
-        if self._should_ignore(range):
-            return
 
         self._diagnostics.append(
             Diagnostic(
@@ -1167,7 +1152,7 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
             for v in entries.values():
                 if v.import_source == self.namespace.source and v.import_range == range_from_token(name_token):
                     for k in self._namespace_references:
-                        if type(k) == type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
+                        if type(k) is type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
                             self._namespace_references[k].add(
                                 Location(self.namespace.document.document_uri, v.import_range)
                             )
@@ -1192,7 +1177,7 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
             for v in entries.values():
                 if v.import_source == self.namespace.source and v.import_range == range_from_token(name_token):
                     for k in self._namespace_references:
-                        if type(k) == type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
+                        if type(k) is type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
                             self._namespace_references[k].add(
                                 Location(self.namespace.document.document_uri, v.import_range)
                             )
@@ -1217,7 +1202,7 @@ class NamespaceAnalyzer(Visitor, ModelHelper):
             for v in entries.values():
                 if v.import_source == self.namespace.source and v.import_range == range_from_token(name_token):
                     for k in self._namespace_references:
-                        if type(k) == type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
+                        if type(k) is type(v) and k.library_doc.source_or_origin == v.library_doc.source_or_origin:
                             self._namespace_references[k].add(
                                 Location(self.namespace.document.document_uri, v.import_range)
                             )

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/utils/ast.py

@@ -129,10 +129,10 @@ def range_from_node(
                         return Range(start=first_range.start, end=last_range.end)
 
     return Range(
-        start=Position(line=node.lineno - 1, character=node.col_offset),
+        start=Position(line=node.lineno - 1, character=node.col_offset),  # type: ignore
         end=Position(
-            line=node.end_lineno - 1 if node.end_lineno is not None else -1,
-            character=node.end_col_offset if node.end_col_offset is not None else -1,
+            line=node.end_lineno - 1 if node.end_lineno is not None else -1,  # type: ignore
+            character=node.end_col_offset if node.end_col_offset is not None else -1,  # type: ignore
         ),
     )
 

{robotcode_robot-0.83.3 → robotcode_robot-0.85.0}/src/robotcode/robot/utils/match.py

@@ -1,9 +1,12 @@
 from functools import lru_cache
 
+_transform_table = str.maketrans("", "", "_ ")
+
 
 @lru_cache(maxsize=5000)
 def normalize(text: str) -> str:
-    return text.lower().replace("_", "").replace(" ", "")
+    # return text.lower().replace("_", "").replace(" ", "")
+    return text.casefold().translate(_transform_table)
 
 
 @lru_cache(maxsize=5000)

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

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