robotcode-language-server 0.106.0__tar.gz → 0.107.0__tar.gz

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-language-server
-Version: 0.106.0
+Version: 0.107.0
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -25,10 +25,10 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-analyze==0.106.0
-Requires-Dist: robotcode-jsonrpc2==0.106.0
-Requires-Dist: robotcode-robot==0.106.0
-Requires-Dist: robotcode==0.106.0
+Requires-Dist: robotcode-analyze==0.107.0
+Requires-Dist: robotcode-jsonrpc2==0.107.0
+Requires-Dist: robotcode-robot==0.107.0
+Requires-Dist: robotcode==0.107.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/pyproject.toml

@@ -27,10 +27,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==0.106.0",
-  "robotcode-robot==0.106.0",
-  "robotcode-analyze==0.106.0",
-  "robotcode==0.106.0",
+  "robotcode-jsonrpc2==0.107.0",
+  "robotcode-robot==0.107.0",
+  "robotcode-analyze==0.107.0",
+  "robotcode==0.107.0",
 ]
 dynamic = ["version"]
 

robotcode_language_server-0.107.0/src/robotcode/language_server/__version__.py

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

robotcode_language_server-0.107.0/src/robotcode/language_server/common/parts/workspace_symbols.py

@@ -0,0 +1,132 @@
+from concurrent.futures import CancelledError
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Final,
+    Iterable,
+    List,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    cast,
+    runtime_checkable,
+)
+
+from robotcode.core.event import event
+from robotcode.core.lsp.types import (
+    Location,
+    ServerCapabilities,
+    SymbolInformation,
+    WorkspaceSymbol,
+    WorkspaceSymbolClientCapabilitiesResolveSupportType,
+    WorkspaceSymbolClientCapabilitiesSymbolKindType,
+    WorkspaceSymbolClientCapabilitiesTagSupportType,
+    WorkspaceSymbolParams,
+)
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.jsonrpc2.protocol import rpc_method
+from robotcode.language_server.common.parts.protocol_part import (
+    LanguageServerProtocolPart,
+)
+
+if TYPE_CHECKING:
+    from robotcode.language_server.common.protocol import LanguageServerProtocol
+
+
+@runtime_checkable
+class HasSymbolInformationLabel(Protocol):
+    symbol_information_label: str
+
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
+def symbol_information_label(label: str) -> Callable[[_F], _F]:
+    def decorator(func: _F) -> _F:
+        setattr(func, "symbol_information_label", label)
+        return func
+
+    return decorator
+
+
+class WorkspaceSymbolsProtocolPart(LanguageServerProtocolPart):
+    _logger: Final = LoggingDescriptor()
+
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
+        super().__init__(parent)
+        self.symbol_kind: Optional[WorkspaceSymbolClientCapabilitiesSymbolKindType] = None
+        self.tag_support: Optional[WorkspaceSymbolClientCapabilitiesTagSupportType] = None
+        self.resolve_support: Optional[WorkspaceSymbolClientCapabilitiesResolveSupportType] = None
+
+    @event
+    def collect(
+        sender,
+        query: str,
+    ) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]: ...
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if (
+            self.parent.client_capabilities
+            and self.parent.client_capabilities.workspace
+            and self.parent.client_capabilities.workspace.symbol is not None
+        ):
+            workspace_symbol = self.parent.client_capabilities.workspace.symbol
+
+            self.symbol_kind = workspace_symbol.symbol_kind
+            self.tag_support = workspace_symbol.tag_support
+            self.resolve_support = workspace_symbol.resolve_support
+
+            if len(self.collect):
+                # TODO: Implement workspace resolve
+                capabilities.workspace_symbol_provider = True
+
+    @rpc_method(name="workspace/symbol", param_type=WorkspaceSymbolParams, threaded=True)
+    def _workspace_symbol(
+        self, query: str, *args: Any, **kwargs: Any
+    ) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]:
+        workspace_symbols: List[WorkspaceSymbol] = []
+        symbol_informations: List[SymbolInformation] = []
+
+        for result in self.collect(self, query):
+            if isinstance(result, BaseException):
+                if not isinstance(result, CancelledError):
+                    self._logger.exception(result, exc_info=result)
+            else:
+                if result is not None:
+                    if all(isinstance(e, WorkspaceSymbol) for e in result):
+                        workspace_symbols.extend(cast(Iterable[WorkspaceSymbol], result))
+                    elif all(isinstance(e, SymbolInformation) for e in result):
+                        symbol_informations.extend(cast(Iterable[SymbolInformation], result))
+                    else:
+                        self._logger.warning(
+                            "Result contains WorkspaceSymbol and SymbolInformation results, result is skipped."
+                        )
+
+        if workspace_symbols:
+            for symbol in workspace_symbols:
+                if isinstance(symbol.location, Location):
+                    doc = self.parent.documents.get(symbol.location.uri)
+                    if doc is not None:
+                        symbol.location.range = doc.range_to_utf16(symbol.location.range)
+
+        if symbol_informations:
+            for symbol_information in symbol_informations:
+                doc = self.parent.documents.get(symbol_information.location.uri)
+                if doc is not None:
+                    symbol_information.location.range = doc.range_to_utf16(symbol_information.location.range)
+
+        if workspace_symbols and symbol_informations:
+            self._logger.warning(
+                "Result contains WorksapceSymbol and SymbolInformation results, only WorkspaceSymbols returned."
+            )
+            return workspace_symbols
+
+        if workspace_symbols:
+            return workspace_symbols
+
+        if symbol_informations:
+            return symbol_informations
+
+        return None

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/src/robotcode/language_server/common/protocol.py

@@ -71,6 +71,7 @@ from .parts.semantic_tokens import SemanticTokensProtocolPart
 from .parts.signature_help import SignatureHelpProtocolPart
 from .parts.window import WindowProtocolPart
 from .parts.workspace import Workspace
+from .parts.workspace_symbols import WorkspaceSymbolsProtocolPart
 
 __all__ = ["LanguageServerException", "LanguageServerProtocol"]
 
@@ -133,6 +134,7 @@ class LanguageServerProtocol(JsonRPCProtocol):
     inline_value: Final = ProtocolPartDescriptor(InlineValueProtocolPart)
     inlay_hint: Final = ProtocolPartDescriptor(InlayHintProtocolPart)
     code_action: Final = ProtocolPartDescriptor(CodeActionProtocolPart)
+    workspace_symbols: Final = ProtocolPartDescriptor(WorkspaceSymbolsProtocolPart)
 
     name: Optional[str] = None
     short_name: Optional[str] = None

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/src/robotcode/language_server/robotframework/parts/code_action_documentation.py

@@ -113,26 +113,18 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
 
                         if kw_doc.libtype == "LIBRARY":
                             entry = next(
-                                (
-                                    v
-                                    for v in (namespace.get_libraries()).values()
-                                    if v.library_doc.digest == kw_doc.parent_digest
-                                ),
+                                (v for v in (namespace.get_libraries()).values() if v.library_doc == kw_doc.parent),
                                 None,
                             )
 
                         elif kw_doc.libtype == "RESOURCE":
                             entry = next(
-                                (
-                                    v
-                                    for v in (namespace.get_resources()).values()
-                                    if v.library_doc.digest == kw_doc.parent_digest
-                                ),
+                                (v for v in (namespace.get_resources()).values() if v.library_doc == kw_doc.parent),
                                 None,
                             )
 
                             self_libdoc = namespace.get_library_doc()
-                            if entry is None and self_libdoc.digest == kw_doc.parent_digest:
+                            if entry is None and self_libdoc == kw_doc.parent:
                                 entry = LibraryEntry(
                                     self_libdoc.name,
                                     str(document.uri.to_path().name),

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/src/robotcode/language_server/robotframework/parts/document_symbols.py

@@ -94,7 +94,7 @@ class _Visitor(Visitor):
             r = range_from_node(node)
             symbol = DocumentSymbol(
                 name=node.name,
-                kind=SymbolKind.METHOD,
+                kind=SymbolKind.CLASS,
                 range=r,
                 selection_range=r,
                 children=[],

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/src/robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -537,7 +537,9 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                                 ignore_errors=True,
                                 identifiers="$@&%",
                             ):
-                                for e in self.generate_sem_sub_tokens(namespace, builtin_library_doc, sub_token, node):
+                                for e in self.generate_sem_sub_tokens(
+                                    namespace, builtin_library_doc, sub_token, node, yield_arguments=True
+                                ):
                                     e.sem_modifiers = {RobotSemTokenModifiers.EMBEDDED}
                                     yield e
 

robotcode_language_server-0.107.0/src/robotcode/language_server/robotframework/parts/workspace_symbols.py

@@ -0,0 +1,88 @@
+from typing import TYPE_CHECKING, Any, List, Optional, Union
+
+from robotcode.core.lsp.types import (
+    Location,
+    SymbolInformation,
+    SymbolKind,
+    SymbolTag,
+    WorkspaceSymbol,
+)
+from robotcode.core.utils.logging import LoggingDescriptor
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+
+def contains_characters_in_order(main_string: str, check_string: str) -> bool:
+    main_iter = iter(main_string.lower())
+    return all(char in main_iter for char in check_string.lower())
+
+
+class RobotWorkspaceSymbolsProtocolPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+
+        parent.workspace_symbols.collect.add(self.collect)
+
+    @_logger.call
+    def collect(self, sender: Any, query: str) -> Optional[Union[List[WorkspaceSymbol], List[SymbolInformation], None]]:
+        result: List[WorkspaceSymbol] = []
+        for document in self.parent.documents.documents:
+            if document.language_id == "robotframework":
+                namespace = self.parent.documents_cache.get_only_initialized_namespace(document)
+                if namespace is not None:
+                    container_name = namespace.get_library_doc().name
+
+                    for kw_doc in [
+                        v
+                        for v in namespace.get_keyword_references().keys()
+                        if v.source == namespace.source and contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=kw_doc.name,
+                                kind=SymbolKind.FUNCTION,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=kw_doc.range,
+                                ),
+                                tags=[SymbolTag.DEPRECATED] if kw_doc.is_deprecated else None,
+                                container_name=container_name,
+                            )
+                        )
+                    for var in [
+                        v
+                        for v in namespace.get_variable_references().keys()
+                        if v.source == namespace.source and contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=var.name,
+                                kind=SymbolKind.VARIABLE,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=var.range,
+                                ),
+                                container_name=container_name,
+                            )
+                        )
+
+                    for test in [
+                        v for v in namespace.get_testcase_definitions() if contains_characters_in_order(v.name, query)
+                    ]:
+                        result.append(
+                            WorkspaceSymbol(
+                                name=test.name,
+                                kind=SymbolKind.CLASS,
+                                location=Location(
+                                    uri=document.document_uri,
+                                    range=test.range,
+                                ),
+                                container_name=container_name,
+                            )
+                        )
+        return result

{robotcode_language_server-0.106.0 → robotcode_language_server-0.107.0}/src/robotcode/language_server/robotframework/protocol.py

@@ -52,6 +52,7 @@ from .parts.robot_workspace import RobotWorkspaceProtocolPart
 from .parts.selection_range import RobotSelectionRangeProtocolPart
 from .parts.semantic_tokens import RobotSemanticTokenProtocolPart
 from .parts.signature_help import RobotSignatureHelpProtocolPart
+from .parts.workspace_symbols import RobotWorkspaceSymbolsProtocolPart
 
 if TYPE_CHECKING:
     from .server import RobotLanguageServer
@@ -118,6 +119,7 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     robot_debugging_utils = ProtocolPartDescriptor(RobotDebuggingUtilsProtocolPart)
     robot_keywords_treeview = ProtocolPartDescriptor(RobotKeywordsTreeViewPart)
     robot_project_info = ProtocolPartDescriptor(ProjectInfoPart)
+    robot_workspace_symbols = ProtocolPartDescriptor(RobotWorkspaceSymbolsProtocolPart)
 
     http_server = ProtocolPartDescriptor(HttpServerProtocolPart)
 

robotcode_language_server-0.106.0/src/robotcode/language_server/__version__.py

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