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

robotcode/robot/diagnostics/library_doc.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+import functools
 import hashlib
 import importlib
 import importlib.util
@@ -61,7 +62,6 @@ from robot.variables import Variables
 from robot.variables.filesetter import PythonImporter, YamlImporter
 from robot.variables.finders import VariableFinder
 from robot.variables.replacer import VariableReplacer
-from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.core.utils.path import normalized_path
 from robotcode.robot.diagnostics.entities import (
@@ -83,6 +83,8 @@ from robotcode.robot.utils.markdownformatter import MarkDownFormatter
 from robotcode.robot.utils.match import normalize, normalize_namespace
 from robotcode.robot.utils.stubs import HasError, HasErrors
 
+from ..utils.variables import contains_variable
+
 if get_robot_version() < (7, 0):
     from robot.running.handlers import _PythonHandler, _PythonInitHandler  # pyright: ignore[reportMissingImports]
     from robot.running.model import ResourceFile  # pyright: ignore[reportMissingImports]
@@ -197,14 +199,29 @@ def convert_from_rest(text: str) -> str:
     return text
 
 
+if get_robot_version() >= (6, 0):
+
+    @functools.lru_cache(maxsize=None)
+    def _get_embedded_arguments(name: str) -> Any:
+        try:
+            return EmbeddedArguments.from_name(name)
+        except (VariableError, DataError):
+            return ()
+
+else:
+
+    @functools.lru_cache(maxsize=None)
+    def _get_embedded_arguments(name: str) -> Any:
+        try:
+            return EmbeddedArguments(name)
+        except (VariableError, DataError):
+            return ()
+
+
 def is_embedded_keyword(name: str) -> bool:
     try:
-        if get_robot_version() >= (6, 0):
-            if EmbeddedArguments.from_name(name):
-                return True
-        else:
-            if EmbeddedArguments(name):
-                return True
+        if _get_embedded_arguments(name):
+            return True
     except (VariableError, DataError):
         return True
 
@@ -235,18 +252,22 @@ class KeywordMatcher:
     def embedded_arguments(self) -> Any:
         if self._embedded_arguments is None:
             if self._can_have_embedded:
-                try:
-                    if get_robot_version() >= (6, 0):
-                        self._embedded_arguments = EmbeddedArguments.from_name(self.name)
-                    else:
-                        self._embedded_arguments = EmbeddedArguments(self.name)
-                except (VariableError, DataError):
-                    self._embedded_arguments = ()
+                self._embedded_arguments = _get_embedded_arguments(self.name)
             else:
                 self._embedded_arguments = ()
 
         return self._embedded_arguments
 
+    if get_robot_version() >= (6, 0):
+
+        def __match_embedded(self, name: str) -> bool:
+            return self.embedded_arguments.match(name) is not None
+
+    else:
+
+        def __match_embedded(self, name: str) -> bool:
+            return self.embedded_arguments.name.match(name) is not None
+
     def __eq__(self, o: object) -> bool:
         if cached_isinstance(o, KeywordMatcher):
             if self._is_namespace != o._is_namespace:
@@ -261,10 +282,7 @@ class KeywordMatcher:
             return False
 
         if self.embedded_arguments:
-            if get_robot_version() >= (6, 0):
-                return self.embedded_arguments.match(o) is not None
-
-            return self.embedded_arguments.name.match(o) is not None
+            return self.__match_embedded(o)
 
         return self.normalized_name == str(normalize_namespace(o) if self._is_namespace else normalize(o))
 
@@ -908,8 +926,7 @@ class KeywordStore:
         return self.__matchers
 
     def __getitem__(self, key: str) -> KeywordDoc:
-        key_matcher = KeywordMatcher(key)
-        items = [(k, v) for k, v in self._matchers.items() if k == key_matcher]
+        items = [(k, v) for k, v in self._matchers.items() if k == key]
 
         if not items:
             raise KeyError
@@ -936,8 +953,6 @@ class KeywordStore:
         )
 
     def __contains__(self, _x: object) -> bool:
-        if not isinstance(_x, KeywordMatcher):
-            _x = KeywordMatcher(str(_x))
         return any(k == _x for k in self._matchers.keys())
 
     def __len__(self) -> int:
@@ -968,8 +983,7 @@ class KeywordStore:
         return list(self.iter_all(key))
 
     def iter_all(self, key: str) -> Iterable[KeywordDoc]:
-        key_matcher = KeywordMatcher(key)
-        yield from (v for k, v in self._matchers.items() if k == key_matcher)
+        yield from (v for k, v in self._matchers.items() if k == key)
 
 
 @dataclass
@@ -1282,10 +1296,12 @@ class VariablesDoc(LibraryDoc):
         return result
 
 
+@functools.lru_cache(maxsize=256)
 def is_library_by_path(path: str) -> bool:
     return path.lower().endswith((".py", "/", os.sep))
 
 
+@functools.lru_cache(maxsize=256)
 def is_variables_by_path(path: str) -> bool:
     if get_robot_version() >= (6, 1):
         return path.lower().endswith((".py", ".yml", ".yaml", ".json", "/", os.sep))
@@ -1656,9 +1672,8 @@ def _find_library_internal(
 
     robot_variables = None
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -1711,6 +1726,52 @@ def get_robot_library_html_doc_str(
         return output.getvalue()
 
 
+class _Logger(AbstractLogger):
+    def __init__(self) -> None:
+        super().__init__()
+        self.messages: List[Tuple[str, str, bool]] = []
+
+    def write(self, message: str, level: str, html: bool = False) -> None:
+        self.messages.append((message, level, html))
+
+
+def _import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
+    with OutputCapturer(library_import=True):
+        importer = Importer("test library", LOGGER)
+        return importer.import_class_or_module(name, return_source=True)
+
+
+def _get_test_library(
+    libcode: Any,
+    source: str,
+    name: str,
+    args: Optional[Tuple[Any, ...]] = None,
+    variables: Optional[Dict[str, Optional[Any]]] = None,
+    create_handlers: bool = True,
+    logger: Any = LOGGER,
+) -> Any:
+    if get_robot_version() < (7, 0):
+        libclass = robot.running.testlibraries._get_lib_class(libcode)
+        lib = libclass(libcode, name, args or [], source, logger, variables)
+        if create_handlers:
+            lib.create_handlers()
+    else:
+        lib = robot.running.testlibraries.TestLibrary.from_code(
+            libcode,
+            name,
+            source=Path(source),
+            args=args or [],
+            variables=variables,
+            create_keywords=create_handlers,
+            logger=logger,
+        )
+
+    return lib
+
+
+_T = TypeVar("_T")
+
+
 def get_library_doc(
     name: str,
     args: Optional[Tuple[Any, ...]] = None,
@@ -1719,45 +1780,6 @@ def get_library_doc(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> LibraryDoc:
-    class Logger(AbstractLogger):
-        def __init__(self) -> None:
-            super().__init__()
-            self.messages: List[Tuple[str, str, bool]] = []
-
-        def write(self, message: str, level: str, html: bool = False) -> None:
-            self.messages.append((message, level, html))
-
-    def import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
-        with OutputCapturer(library_import=True):
-            importer = Importer("test library", LOGGER)
-            return importer.import_class_or_module(name, return_source=True)
-
-    def get_test_library(
-        libcode: Any,
-        source: str,
-        name: str,
-        args: Optional[Tuple[Any, ...]] = None,
-        variables: Optional[Dict[str, Optional[Any]]] = None,
-        create_handlers: bool = True,
-        logger: Any = LOGGER,
-    ) -> Any:
-        if get_robot_version() < (7, 0):
-            libclass = robot.running.testlibraries._get_lib_class(libcode)
-            lib = libclass(libcode, name, args or [], source, logger, variables)
-            if create_handlers:
-                lib.create_handlers()
-        else:
-            lib = robot.running.testlibraries.TestLibrary.from_code(
-                libcode,
-                name,
-                source=Path(source),
-                args=args or [],
-                variables=variables,
-                create_keywords=create_handlers,
-                logger=logger,
-            )
-
-        return lib
 
     with _std_capture() as std_capturer:
         import_name, robot_variables = _find_library_internal(
@@ -1781,7 +1803,7 @@ def get_library_doc(
 
         source = None
         try:
-            libcode, source = import_test_library(import_name)
+            libcode, source = _import_test_library(import_name)
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1821,13 +1843,17 @@ def get_library_doc(
 
         lib = None
         try:
-            lib = get_test_library(
+            lib = _get_test_library(
                 libcode,
                 source,
                 library_name,
                 args,
                 create_handlers=False,
-                variables=robot_variables,
+                variables=(
+                    robot_variables
+                    if robot_variables is not None
+                    else resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                ),
             )
             if get_robot_version() < (7, 0):
                 _ = lib.get_instance()
@@ -1847,7 +1873,7 @@ def get_library_doc(
 
             if args:
                 try:
-                    lib = get_test_library(libcode, source, library_name, (), create_handlers=False)
+                    lib = _get_test_library(libcode, source, library_name, (), create_handlers=False)
                     if get_robot_version() < (7, 0):
                         _ = lib.get_instance()
                     else:
@@ -1862,6 +1888,10 @@ def get_library_doc(
         libdoc = LibraryDoc(
             name=library_name,
             source=real_source,
+            line_no=lib.lineno if lib is not None else -1,
+            version=str(lib.version) if lib is not None else "",
+            scope=str(lib.scope) if lib is not None else ROBOT_DEFAULT_SCOPE,
+            doc_format=(str(lib.doc_format) or ROBOT_DOC_FORMAT) if lib is not None else ROBOT_DOC_FORMAT,
             module_spec=(
                 module_spec
                 if module_spec is not None
@@ -1870,16 +1900,33 @@ def get_library_doc(
                 else None
             ),
             python_path=sys.path,
-            line_no=lib.lineno if lib is not None else -1,
-            doc=str(lib.doc) if lib is not None else "",
-            version=str(lib.version) if lib is not None else "",
-            scope=str(lib.scope) if lib is not None else ROBOT_DEFAULT_SCOPE,
-            doc_format=(str(lib.doc_format) or ROBOT_DOC_FORMAT) if lib is not None else ROBOT_DOC_FORMAT,
             member_name=module_spec.member_name if module_spec is not None else None,
         )
 
         if lib is not None:
             try:
+
+                def _get(handler: Callable[[], _T]) -> Optional[_T]:
+                    try:
+                        return handler()
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except BaseException as e:
+                        errors.append(
+                            error_from_exception(
+                                e,
+                                source or module_spec.origin if module_spec is not None else None,
+                                (
+                                    1
+                                    if source is not None or module_spec is not None and module_spec.origin is not None
+                                    else None
+                                ),
+                            )
+                        )
+                    return None
+
+                libdoc.doc = _get(lambda: str(lib.doc) if lib is not None else "") or ""
+
                 if get_robot_version() < (7, 0):
                     libdoc.has_listener = lib.has_listener
 
@@ -1909,10 +1956,10 @@ def get_library_doc(
                     keywords=[
                         KeywordDoc(
                             name=libdoc.name,
-                            arguments=[ArgumentInfo.from_robot(a) for a in kw[0].args],
-                            doc=kw[0].doc,
-                            tags=list(kw[0].tags),
-                            source=kw[0].source,
+                            arguments=_get(lambda: [ArgumentInfo.from_robot(a) for a in kw[0].args]) or [],
+                            doc=_get(lambda: kw[0].doc) or "",
+                            tags=_get(lambda: list(kw[0].tags)) or [],
+                            source=_get(lambda: kw[0].source) or "",
                             line_no=kw[0].lineno if kw[0].lineno is not None else -1,
                             col_offset=-1,
                             end_col_offset=-1,
@@ -1923,20 +1970,23 @@ def get_library_doc(
                             longname=f"{libdoc.name}.{kw[0].name}",
                             doc_format=str(lib.doc_format) or ROBOT_DOC_FORMAT,
                             is_initializer=True,
-                            arguments_spec=ArgumentSpec.from_robot_argument_spec(
-                                kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                            arguments_spec=_get(
+                                lambda: ArgumentSpec.from_robot_argument_spec(
+                                    kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                                )
                             ),
                         )
                         for kw in init_keywords
                     ]
                 )
 
-                logger = Logger()
-                lib.logger = logger
+                logger = _Logger()
 
                 if get_robot_version() < (7, 0):
+                    lib.logger = logger
                     lib.create_handlers()
                 else:
+                    lib._logger = logger
                     lib.create_keywords()
 
                 for m in logger.messages:
@@ -1969,10 +2019,10 @@ def get_library_doc(
                     keywords=[
                         KeywordDoc(
                             name=kw[0].name,
-                            arguments=[ArgumentInfo.from_robot(a) for a in kw[0].args],
-                            doc=kw[0].doc,
-                            tags=list(kw[0].tags),
-                            source=kw[0].source,
+                            arguments=_get(lambda: [ArgumentInfo.from_robot(a) for a in kw[0].args]) or [],
+                            doc=_get(lambda: kw[0].doc) or "",
+                            tags=_get(lambda: list(kw[0].tags)) or [],
+                            source=_get(lambda: kw[0].source) or "",
                             line_no=kw[0].lineno if kw[0].lineno is not None else -1,
                             col_offset=-1,
                             end_col_offset=-1,
@@ -1987,21 +2037,26 @@ def get_library_doc(
                             is_registered_run_keyword=RUN_KW_REGISTER.is_run_keyword(libdoc.name, kw[0].name),
                             args_to_process=get_args_to_process(libdoc.name, kw[0].name),
                             deprecated=kw[0].deprecated,
-                            arguments_spec=(
-                                ArgumentSpec.from_robot_argument_spec(
-                                    kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                            arguments_spec=_get(
+                                lambda: (
+                                    ArgumentSpec.from_robot_argument_spec(
+                                        kw[1].arguments if get_robot_version() < (7, 0) else kw[1].args
+                                    )
+                                    if not kw[1].is_error_handler
+                                    else None
                                 )
-                                if not kw[1].is_error_handler
-                                else None
                             ),
-                            return_type=(
-                                (
-                                    str(kw[1].args.return_type)
-                                    if kw[1].args.return_type is not None and kw[1].args.return_type is not type(None)
+                            return_type=_get(
+                                lambda: (
+                                    (
+                                        str(kw[1].args.return_type)
+                                        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)
                                     else None
                                 )
-                                if get_robot_version() >= (7, 0)
-                                else None
                             ),
                         )
                         for kw in keyword_docs
@@ -2086,9 +2141,8 @@ def _find_variables_internal(
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2109,12 +2163,18 @@ def resolve_args(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Tuple[Any, ...]:
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    # robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    robot_variables: Any = None
 
     result = []
     for arg in args:
         if isinstance(arg, str):
-            result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            if contains_variable(arg, "$@&%"):
+                if robot_variables is None:
+                    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+                result.append(robot_variables.replace_string(arg, ignore_errors=True))
+            else:
+                result.append(arg)
         else:
             result.append(arg)
 
@@ -2389,8 +2449,8 @@ def find_file(
 ) -> str:
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
     if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
         try:
             name = robot_variables.replace_string(name, ignore_errors=False)
         except DataError as error:
@@ -2492,7 +2552,7 @@ def complete_library_import(
             if e not in DEFAULT_LIBRARIES
         ]
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2568,7 +2628,7 @@ def complete_resource_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)
@@ -2608,7 +2668,7 @@ def complete_variables_import(
 
     result: List[CompleteResult] = []
 
-    if name is not None:
+    if name is not None and contains_variable(name, "$@&%"):
         robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
         name = robot_variables.replace_string(name, ignore_errors=True)

robotcode/robot/diagnostics/model_helper.py

@@ -21,9 +21,8 @@ from typing import (
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, search_variable
 from robotcode.core.lsp.types import Position
 
 from ..utils import get_robot_version
@@ -35,6 +34,7 @@ from ..utils.ast import (
     whitespace_at_begin_of_token,
     whitespace_from_begin_of_token,
 )
+from ..utils.variables import contains_variable, search_variable, split_from_equals
 from .entities import (
     LibraryEntry,
     VariableDefinition,
@@ -210,10 +210,14 @@ class ModelHelper:
         position: Position,
         analyse_run_keywords: bool = True,
     ) -> Optional[Tuple[Optional[KeywordDoc], Token]]:
-        keyword_doc = namespace.find_keyword(keyword_name, raise_keyword_error=False)
+        finder = namespace.get_finder()
+        keyword_doc = finder.find_keyword(keyword_name, raise_keyword_error=False)
         if keyword_doc is None:
             return None
 
+        if finder.result_bdd_prefix:
+            keyword_token = ModelHelper.strip_bdd_prefix(namespace, keyword_token)
+
         if position.is_in_range(range_from_token(keyword_token)):
             return keyword_doc, keyword_token
 

robotcode/robot/diagnostics/namespace.py

@@ -1,7 +1,6 @@
 import ast
 import enum
 import itertools
-import time
 import weakref
 from collections import OrderedDict, defaultdict
 from concurrent.futures import CancelledError
@@ -29,11 +28,6 @@ from robot.parsing.model.statements import ResourceImport as RobotResourceImport
 from robot.parsing.model.statements import (
     VariablesImport as RobotVariablesImport,
 )
-from robot.variables.search import (
-    is_scalar_assign,
-    is_variable,
-    search_variable,
-)
 from robotcode.core.concurrent import RLock
 from robotcode.core.event import event
 from robotcode.core.lsp.types import (
@@ -58,7 +52,12 @@ from ..utils.ast import (
     tokenize_variables,
 )
 from ..utils.stubs import Languages
-from ..utils.variables import BUILTIN_VARIABLES
+from ..utils.variables import (
+    BUILTIN_VARIABLES,
+    is_scalar_assign,
+    is_variable,
+    search_variable,
+)
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,
@@ -894,6 +893,7 @@ class Namespace:
                 self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
             for v in (self.get_resources()).values():
                 self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
+
         return self._namespaces
 
     def get_resources(self) -> Dict[str, ResourceEntry]:
@@ -1794,38 +1794,27 @@ class Namespace:
 
         libdoc = self.get_library_doc()
 
-        for doc in itertools.chain(
+        yield from itertools.chain(
             self.get_imported_keywords(),
             libdoc.keywords if libdoc is not None else [],
-        ):
-            yield doc
+        )
 
     @_logger.call
     def get_keywords(self) -> List[KeywordDoc]:
         with self._keywords_lock:
             if self._keywords is None:
-                current_time = time.monotonic()
-                self._logger.debug("start collecting keywords")
-                try:
-                    i = 0
 
-                    self.ensure_initialized()
+                i = 0
 
-                    result: Dict[KeywordMatcher, KeywordDoc] = {}
+                self.ensure_initialized()
 
-                    for doc in self.iter_all_keywords():
-                        i += 1
-                        result[doc.matcher] = doc
+                result: Dict[KeywordMatcher, KeywordDoc] = {}
 
-                    self._keywords = list(result.values())
-                except BaseException:
-                    self._logger.debug("Canceled collecting keywords ")
-                    raise
-                else:
-                    self._logger.debug(
-                        lambda: f"end collecting {len(self._keywords) if self._keywords else 0}"
-                        f" keywords in {time.monotonic() - current_time}s analyze {i} keywords"
-                    )
+                for doc in self.iter_all_keywords():
+                    i += 1
+                    result[doc.matcher] = doc
+
+                self._keywords = list(result.values())
 
             return self._keywords