robotcode-robot 0.94.0__py3-none-any.whl → 0.95.1__py3-none-any.whl

robotcode/robot/diagnostics/keyword_finder.py

@@ -1,3 +1,5 @@
+import functools
+import re
 from itertools import chain
 from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, NamedTuple, Optional, Sequence, Tuple
 
@@ -42,6 +44,8 @@ class KeywordFinder:
         self.self_library_doc = library_doc
 
         self.diagnostics: List[DiagnosticsEntry] = []
+        self.result_bdd_prefix: Optional[str] = None
+
         self.multiple_keywords_result: Optional[List[KeywordDoc]] = None
         self._cache: Dict[
             Tuple[Optional[str], bool],
@@ -49,17 +53,20 @@ class KeywordFinder:
                 Optional[KeywordDoc],
                 List[DiagnosticsEntry],
                 Optional[List[KeywordDoc]],
+                Optional[str],
             ],
         ] = {}
-        self.handle_bdd_style = True
+
         self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_keywords: Optional[List[ResourceEntry]] = None
-        self._library_keywords: Optional[List[LibraryEntry]] = None
+        self._resource_imports: Optional[List[ResourceEntry]] = None
+        self._library_imports: Optional[List[LibraryEntry]] = None
 
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
         self.multiple_keywords_result = None
+        self.result_bdd_prefix = None
 
+    # TODO: make this threadsafe
     def find_keyword(
         self,
         name: Optional[str],
@@ -70,17 +77,16 @@ class KeywordFinder:
         try:
             self.reset_diagnostics()
 
-            self.handle_bdd_style = handle_bdd_style
-
-            cached = self._cache.get((name, self.handle_bdd_style), None)
+            cached = self._cache.get((name, handle_bdd_style), None)
 
             if cached is not None:
                 self.diagnostics = cached[1]
                 self.multiple_keywords_result = cached[2]
+                self.result_bdd_prefix = cached[3]
                 return cached[0]
 
             try:
-                result = self._find_keyword(name)
+                result = self._find_keyword(name, handle_bdd_style)
                 if result is None:
                     self.diagnostics.append(
                         DiagnosticsEntry(
@@ -99,17 +105,22 @@ class KeywordFinder:
                 result = None
                 self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, Error.KEYWORD_ERROR))
 
-            self._cache[(name, self.handle_bdd_style)] = (
+            self._cache[(name, handle_bdd_style)] = (
                 result,
                 self.diagnostics,
                 self.multiple_keywords_result,
+                self.result_bdd_prefix,
             )
 
             return result
         except CancelSearchError:
             return None
 
-    def _find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
+    def _find_keyword(
+        self,
+        name: Optional[str],
+        handle_bdd_style: bool = True,
+    ) -> Optional[KeywordDoc]:
         if not name:
             self.diagnostics.append(
                 DiagnosticsEntry(
@@ -129,14 +140,21 @@ class KeywordFinder:
             )
             raise CancelSearchError
 
-        result = self._get_keyword_from_self(name)
+        result: Optional[KeywordDoc] = None
+
+        if get_robot_version() >= (7, 0) and handle_bdd_style:
+            result = self._get_bdd_style_keyword(name)
+
+        if not result:
+            result = self._get_keyword_from_self(name)
+
         if not result and "." in name:
             result = self._get_explicit_keyword(name)
 
         if not result:
             result = self._get_implicit_keyword(name)
 
-        if not result and self.handle_bdd_style:
+        if get_robot_version() < (7, 0) and not result and handle_bdd_style:
             return self._get_bdd_style_keyword(name)
 
         return result
@@ -264,6 +282,9 @@ class KeywordFinder:
     def _select_best_matches(
         self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
+        if len(entries) < 2:
+            return entries
+
         normal = [hand for hand in entries if not hand[1].is_embedded]
         if normal:
             return normal
@@ -291,23 +312,23 @@ class KeywordFinder:
         other: Tuple[Optional[LibraryEntry], KeywordDoc],
     ) -> bool:
         return (
-            other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
+            other[1].matcher.embedded_arguments is not None
+            and candidate[1].matcher.embedded_arguments is not None
+            and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
             and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
         )
 
     def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
-        if self._resource_keywords is None:
-            self._resource_keywords = list(chain(self.namespace._resources.values()))
+        if self._resource_imports is None:
+            self._resource_imports = list(chain(self.namespace._resources.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._resource_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._resource_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
         else:
             found = []
-            for k in self._resource_keywords:
+            for k in self._resource_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -352,19 +373,18 @@ class KeywordFinder:
         return entries
 
     def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_keywords is None:
-            self._library_keywords = list(chain(self.namespace._libraries.values()))
+        if self._library_imports is None:
+            self._library_imports = list(chain(self.namespace._libraries.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._library_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._library_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
+
         else:
             found = []
 
-            for k in self._library_keywords:
+            for k in self._library_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -438,21 +458,27 @@ class KeywordFinder:
             f"or '{'' if standard[0] is None else standard[0].alias or standard[0].name}.{standard[1].name}'."
         )
 
+    @functools.cached_property
+    def bdd_prefix_regexp(self) -> "re.Pattern[str]":
+        prefixes = (
+            "|".join(
+                self.namespace.languages.bdd_prefixes
+                if self.namespace.languages is not None
+                else ["given", "when", "then", "and", "but"]
+            )
+            .replace(" ", r"\s")
+            .lower()
+        )
+        return re.compile(rf"({prefixes})\s", re.IGNORECASE)
+
     def _get_bdd_style_keyword(self, name: str) -> Optional[KeywordDoc]:
-        if get_robot_version() < (6, 0):
-            lower = name.lower()
-            for prefix in ["given ", "when ", "then ", "and ", "but "]:
-                if lower.startswith(prefix):
-                    return self._find_keyword(name[len(prefix) :])
-            return None
+        match = self.bdd_prefix_regexp.match(name)
+        if match:
+            result = self._find_keyword(
+                name[match.end() :], handle_bdd_style=False if get_robot_version() >= (7, 0) else True
+            )
+            if result:
+                self.result_bdd_prefix = str(match.group(0))
 
-        parts = name.split()
-        if len(parts) < 2:
-            return None
-        for index in range(1, len(parts)):
-            prefix = " ".join(parts[:index]).title()
-            if prefix.title() in (
-                self.namespace.languages.bdd_prefixes if self.namespace.languages is not None else DEFAULT_BDD_PREFIXES
-            ):
-                return self._find_keyword(" ".join(parts[index:]))
+            return result
         return None