robotcode-robot 2.5.0__tar.gz → 2.5.1__tar.gz

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-robot
-Version: 2.5.0
+Version: 2.5.1
 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.5.1/src/robotcode/robot/__version__.py

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

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/document_cache_helper.py

@@ -496,9 +496,17 @@ class DocumentsCacheHelper:
             return None
 
         if entry is None or entry.meta is None:
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: no cached entry found",
+                context_name="cache",
+            )
             return None
 
         if not imports_manager.validate_namespace_meta(entry.meta):
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: cached entry is stale, re-analyzing",
+                context_name="cache",
+            )
             return None
 
         # Meta is valid — load the full NamespaceData (lazy deserialization)

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/imports_manager.py

@@ -835,20 +835,37 @@ class ImportsManager:
         Level 1 (fast): source_mtime_ns, config_fingerprint
         Level 2 (dependency check): each dependency fingerprint
         """
+        source = meta.source
+
         # Level 1: fast checks
         try:
-            current_mtime = os.stat(meta.source, follow_symlinks=False).st_mtime_ns
+            current_mtime = os.stat(source, follow_symlinks=False).st_mtime_ns
         except OSError:
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: source file no longer exists",
+                context_name="cache",
+            )
             return False
 
         if meta.source_mtime_ns != current_mtime:
+            self._logger.debug(
+                lambda: (
+                    f"Cache miss for {source}: source mtime changed"
+                    f" (cached={meta.source_mtime_ns}, current={current_mtime})"
+                ),
+                context_name="cache",
+            )
             return False
 
         if meta.config_fingerprint != self.config_fingerprint:
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: config fingerprint changed",
+                context_name="cache",
+            )
             return False
 
         # Level 2: dependency checks — direct comparison, no hashing
-        base_dir = os.path.dirname(meta.source)
+        base_dir = os.path.dirname(source)
         for key, saved_value in meta.dependency_fingerprints.items():
             if key.startswith("lib:"):
                 lib_name = key[4:]
@@ -857,10 +874,22 @@ class ImportsManager:
                     if lib_meta is None:
                         lib_meta, _, _ = self.get_library_meta(lib_name, base_dir=base_dir)
                     if lib_meta is None or lib_meta != saved_value:
+                        self._logger.debug(
+                            lambda: (
+                                f"Cache miss for {source}: library {lib_name!r} changed"
+                                f" (found={'yes' if lib_meta is not None else 'no'})"
+                            ),
+                            context_name="cache",
+                        )
                         return False
                 except (SystemExit, KeyboardInterrupt):
                     raise
-                except BaseException:
+                except BaseException as e:
+                    ex = e
+                    self._logger.debug(
+                        lambda: f"Cache miss for {source}: error checking library {lib_name!r}: {ex}",
+                        context_name="cache",
+                    )
                     return False
             elif key.startswith("res:"):
                 res_source = key[4:]
@@ -869,10 +898,22 @@ class ImportsManager:
                     if res_meta is None:
                         res_meta = self.get_resource_meta(res_source)
                     if res_meta is None or res_meta != saved_value:
+                        self._logger.debug(
+                            lambda: (
+                                f"Cache miss for {source}: resource {res_source!r} changed"
+                                f" (found={'yes' if res_meta is not None else 'no'})"
+                            ),
+                            context_name="cache",
+                        )
                         return False
                 except (SystemExit, KeyboardInterrupt):
                     raise
-                except BaseException:
+                except BaseException as e:
+                    ex = e
+                    self._logger.debug(
+                        lambda: f"Cache miss for {source}: error checking resource {res_source!r}: {ex}",
+                        context_name="cache",
+                    )
                     return False
             elif key.startswith("var:"):
                 var_name = key[4:]
@@ -881,10 +922,22 @@ class ImportsManager:
                     if var_meta is None:
                         var_meta, _ = self.get_variables_meta(var_name, base_dir=base_dir)
                     if var_meta is None or var_meta != saved_value:
+                        self._logger.debug(
+                            lambda: (
+                                f"Cache miss for {source}: variables {var_name!r} changed"
+                                f" (found={'yes' if var_meta is not None else 'no'})"
+                            ),
+                            context_name="cache",
+                        )
                         return False
                 except (SystemExit, KeyboardInterrupt):
                     raise
-                except BaseException:
+                except BaseException as e:
+                    ex = e
+                    self._logger.debug(
+                        lambda: f"Cache miss for {source}: error checking variables {var_name!r}: {ex}",
+                        context_name="cache",
+                    )
                     return False
 
         return True

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/keyword_finder.py

@@ -1,7 +1,7 @@
 import functools
 import re
 from itertools import chain
-from typing import Dict, Iterable, Iterator, List, NamedTuple, Optional, Sequence, Tuple
+from typing import Dict, FrozenSet, Iterable, Iterator, List, NamedTuple, Optional, Sequence, Tuple
 
 from robot.libraries import STDLIBS
 from robotcode.core.lsp.types import (
@@ -38,6 +38,16 @@ class CancelSearchError(Exception):
 DEFAULT_BDD_PREFIXES = {"Given ", "When ", "Then ", "And ", "But "}
 
 
+@functools.lru_cache(maxsize=None)
+def build_bdd_prefix_regexp(prefixes: FrozenSet[str]) -> "re.Pattern[str]":
+    sorted_prefixes = sorted(prefixes, key=len, reverse=True)
+    pattern = "|".join(p.strip().replace(" ", r"\s") for p in sorted_prefixes).lower()
+    return re.compile(rf"({pattern})\s", re.IGNORECASE)
+
+
+DEFAULT_BDD_PREFIX_REGEXP = build_bdd_prefix_regexp(frozenset(DEFAULT_BDD_PREFIXES))
+
+
 class KeywordFinder:
     def __init__(
         self,
@@ -501,14 +511,9 @@ class KeywordFinder:
 
     @functools.cached_property
     def bdd_prefix_regexp(self) -> "re.Pattern[str]":
-        prefixes = (
-            "|".join(
-                self._languages.bdd_prefixes if self._languages is not None else ["given", "when", "then", "and", "but"]
-            )
-            .replace(" ", r"\s")
-            .lower()
-        )
-        return re.compile(rf"({prefixes})\s", re.IGNORECASE)
+        if self._languages is not None:
+            return build_bdd_prefix_regexp(frozenset(self._languages.bdd_prefixes))
+        return DEFAULT_BDD_PREFIX_REGEXP
 
     def _get_bdd_style_keyword(self, name: str) -> Optional[KeywordDoc]:
         match = self.bdd_prefix_regexp.match(name)

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/library_doc.py

@@ -79,7 +79,7 @@ from ..utils.ast import (
 from ..utils.markdownformatter import MarkDownFormatter
 from ..utils.match import normalize, normalize_namespace
 from ..utils.robot_patching import patch_variable_not_found
-from ..utils.variables import contains_variable, search_variable
+from ..utils.variables import contains_variable, replace_curdir_in_variable_values, search_variable
 from .entities import (
     ArgumentDefinition,
     Import,
@@ -3199,13 +3199,7 @@ class _MyResourceBuilder(ResourceBuilder):
 
             values = node.get_values(Token.ARGUMENT)
             has_value = bool(values)
-            value = tuple(
-                s.replace(
-                    "${CURDIR}",
-                    str(Path(self.source).parent).replace("\\\\", "\\\\\\\\"),
-                )
-                for s in values
-            )
+            value = replace_curdir_in_variable_values(values, self.source)
 
             stripped_name_token = strip_variable_token(name_token, matcher=matcher, parse_type=True)
 

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/model_helper.py

@@ -39,7 +39,7 @@ from .entities import (
     VariableDefinition,
     VariableNotFoundDefinition,
 )
-from .keyword_finder import DEFAULT_BDD_PREFIXES
+from .keyword_finder import DEFAULT_BDD_PREFIX_REGEXP, build_bdd_prefix_regexp
 from .library_doc import (
     ArgumentInfo,
     KeywordArgumentKind,
@@ -562,38 +562,35 @@ class ModelHelper:
     BDD_TOKEN_REGEX = re.compile(r"^(Given|When|Then|And|But)\s", flags=re.IGNORECASE)
     BDD_TOKEN = re.compile(r"^(Given|When|Then|And|But)$", flags=re.IGNORECASE)
 
+    @classmethod
+    def _get_bdd_prefix_regexp(cls, namespace: "Namespace") -> "re.Pattern[str]":
+        if namespace.languages is not None:
+            return build_bdd_prefix_regexp(frozenset(namespace.languages.bdd_prefixes))
+        return DEFAULT_BDD_PREFIX_REGEXP
+
     @classmethod
     def split_bdd_prefix(cls, namespace: "Namespace", token: Token) -> Tuple[Optional[Token], Optional[Token]]:
-        bdd_token = None
-
-        parts = token.value.split()
-        if len(parts) < 2:
-            return None, token
-
-        for index in range(1, len(parts)):
-            prefix = " ".join(parts[:index]).title()
-            if prefix in (
-                namespace.languages.bdd_prefixes if namespace.languages is not None else DEFAULT_BDD_PREFIXES
-            ):
-                bdd_len = len(prefix)
-                bdd_token = Token(
-                    token.type,
-                    token.value[:bdd_len],
-                    token.lineno,
-                    token.col_offset,
-                    token.error,
-                )
+        bdd_match = cls._get_bdd_prefix_regexp(namespace).match(token.value)
+        if bdd_match:
+            bdd_len = len(bdd_match.group(1))
+            bdd_token = Token(
+                token.type,
+                token.value[:bdd_len],
+                token.lineno,
+                token.col_offset,
+                token.error,
+            )
 
-                token = Token(
-                    token.type,
-                    token.value[bdd_len + 1 :],
-                    token.lineno,
-                    token.col_offset + bdd_len + 1,
-                    token.error,
-                )
-                break
+            token = Token(
+                token.type,
+                token.value[bdd_len + 1 :],
+                token.lineno,
+                token.col_offset + bdd_len + 1,
+                token.error,
+            )
+            return bdd_token, token
 
-        return bdd_token, token
+        return None, token
 
     @classmethod
     def strip_bdd_prefix(cls, namespace: "Namespace", token: Token) -> Token:
@@ -611,24 +608,16 @@ class ModelHelper:
                 )
             return token
 
-        parts = token.value.split()
-        if len(parts) < 2:
-            return token
-
-        for index in range(1, len(parts)):
-            prefix = " ".join(parts[:index]).title()
-            if prefix in (
-                namespace.languages.bdd_prefixes if namespace.languages is not None else DEFAULT_BDD_PREFIXES
-            ):
-                bdd_len = len(prefix)
-                token = Token(
-                    token.type,
-                    token.value[bdd_len + 1 :],
-                    token.lineno,
-                    token.col_offset + bdd_len + 1,
-                    token.error,
-                )
-                break
+        bdd_match = cls._get_bdd_prefix_regexp(namespace).match(token.value)
+        if bdd_match:
+            bdd_len = len(bdd_match.group(1))
+            token = Token(
+                token.type,
+                token.value[bdd_len + 1 :],
+                token.lineno,
+                token.col_offset + bdd_len + 1,
+                token.error,
+            )
 
         return token
 
@@ -638,17 +627,8 @@ class ModelHelper:
             bdd_match = cls.BDD_TOKEN.match(token.value)
             return bool(bdd_match)
 
-        parts = token.value.split()
-
-        for index in range(len(parts)):
-            prefix = " ".join(parts[: index + 1]).title()
-
-            if prefix.title() in (
-                namespace.languages.bdd_prefixes if namespace.languages is not None else DEFAULT_BDD_PREFIXES
-            ):
-                return True
-
-        return False
+        bdd_match = cls._get_bdd_prefix_regexp(namespace).match(token.value + " ")
+        return bdd_match is not None and len(bdd_match.group(1)) == len(token.value)
 
     @classmethod
     def get_keyword_definition_at_token(cls, library_doc: LibraryDoc, token: Token) -> Optional[KeywordDoc]:

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -7,7 +7,6 @@ from collections import defaultdict
 from concurrent.futures import CancelledError
 from dataclasses import dataclass
 from io import StringIO
-from pathlib import Path
 from tokenize import TokenError, generate_tokens
 from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
 
@@ -63,6 +62,7 @@ from ..utils.variables import (
     InvalidVariableError,
     VariableMatcher,
     contains_variable,
+    replace_curdir_in_variable_values,
     search_variable,
     split_from_equals,
 )
@@ -283,13 +283,7 @@ class NamespaceAnalyzer(Visitor):
 
             values = node.get_values(Token.ARGUMENT)
             has_value = bool(values)
-            value = tuple(
-                s.replace(
-                    "${CURDIR}",
-                    str(Path(self._source).parent).replace("\\", "\\\\"),
-                )
-                for s in values
-            )
+            value = replace_curdir_in_variable_values(values, self._source)
 
             var_def = VariableDefinition(
                 name=name,
@@ -697,6 +691,7 @@ class NamespaceAnalyzer(Visitor):
         allow_variables: bool = False,
         ignore_errors_if_contains_variables: bool = False,
         unescape_keyword: bool = True,
+        is_template: bool = False,
     ) -> Optional[KeywordDoc]:
         result: Optional[KeywordDoc] = None
 
@@ -782,7 +777,7 @@ class NamespaceAnalyzer(Visitor):
             else:
                 self._keyword_references[result].add(Location(self._document_uri, kw_range))
 
-                if result.is_embedded:
+                if result.is_embedded and not is_template:
                     self._analyze_token_variables(keyword_token)
 
                 if result.errors:
@@ -1105,6 +1100,7 @@ class NamespaceAnalyzer(Visitor):
                 [],
                 analyze_run_keywords=False,
                 allow_variables=True,
+                is_template=True,
             )
 
         self._test_template = node
@@ -1122,6 +1118,7 @@ class NamespaceAnalyzer(Visitor):
                 [],
                 analyze_run_keywords=False,
                 allow_variables=True,
+                is_template=True,
             )
         self._template = node
 

{robotcode_robot-2.5.0 → robotcode_robot-2.5.1}/src/robotcode/robot/utils/variables.py

@@ -1,5 +1,6 @@
 import functools
-from typing import Any, Optional, Tuple, cast
+from pathlib import Path
+from typing import Any, Optional, Sequence, Tuple, cast
 
 from robot.utils.escaping import split_from_equals as robot_split_from_equals
 from robot.variables.search import contains_variable as robot_contains_variable
@@ -225,3 +226,9 @@ def search_variable(
 @functools.lru_cache(maxsize=1024)
 def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
     return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))
+
+
+def replace_curdir_in_variable_values(values: Sequence[str], source: str) -> Tuple[str, ...]:
+    """Replace ${CURDIR} in variable values with the escaped parent directory of source."""
+    curdir = str(Path(source).parent).replace("\\", "\\\\")
+    return tuple(s.replace("${CURDIR}", curdir) for s in values)

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

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