robotcode-language-server 2.8.0.dev670__tar.gz → 2.9.0.dev51__tar.gz

{robotcode_language_server-2.8.0.dev670 → robotcode_language_server-2.9.0.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-language-server
-Version: 2.8.0-dev.670
+Version: 2.9.0-dev.51
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,10 +26,10 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-analyze==2.8.0-dev.670
-Requires-Dist: robotcode-jsonrpc2==2.8.0-dev.670
-Requires-Dist: robotcode-robot==2.8.0-dev.670
-Requires-Dist: robotcode==2.8.0-dev.670
+Requires-Dist: robotcode-analyze==2.9.0-dev.51
+Requires-Dist: robotcode-jsonrpc2==2.9.0-dev.51
+Requires-Dist: robotcode-robot==2.9.0-dev.51
+Requires-Dist: robotcode==2.9.0-dev.51
 Requires-Dist: robotframework>=5.0.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-2.8.0.dev670 → robotcode_language_server-2.9.0.dev51}/pyproject.toml

@@ -29,10 +29,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=5.0.0",
-  "robotcode-jsonrpc2==2.8.0-dev.670",
-  "robotcode-robot==2.8.0-dev.670",
-  "robotcode-analyze==2.8.0-dev.670",
-  "robotcode==2.8.0-dev.670",
+  "robotcode-jsonrpc2==2.9.0-dev.51",
+  "robotcode-robot==2.9.0-dev.51",
+  "robotcode-analyze==2.9.0-dev.51",
+  "robotcode==2.9.0-dev.51",
 ]
 dynamic = ["version"]
 

robotcode_language_server-2.9.0.dev51/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.9.0-dev.51"

{robotcode_language_server-2.8.0.dev670 → robotcode_language_server-2.9.0.dev51}/src/robotcode/language_server/cli.py

@@ -1,8 +1,9 @@
 import os
 from pathlib import Path
-from typing import Final, Optional, Sequence, Union
+from typing import Any, Callable, Final, List, Optional, Sequence, Union
 
 import click
+from click.core import ParameterSource
 
 from robotcode.analyze.config import AnalyzeConfig
 from robotcode.core.types import ServerMode, TcpParams
@@ -13,7 +14,7 @@ from robotcode.plugin.click_helper.options import (
 )
 from robotcode.plugin.click_helper.types import AddressesPort, add_options
 from robotcode.robot.config.loader import load_robot_config_from_path
-from robotcode.robot.config.model import RobotBaseProfile
+from robotcode.robot.config.model import RobotBaseProfile, UnknownProfile
 from robotcode.robot.config.utils import get_config_files
 from robotcode.robot.diagnostics.workspace_config import WorkspaceAnalysisConfig
 
@@ -29,6 +30,7 @@ def run_server(
     pipe_name: Optional[str],
     profile: Optional[RobotBaseProfile] = None,
     analysis_config: Optional[WorkspaceAnalysisConfig] = None,
+    configuration_errors: Optional[List[str]] = None,
 ) -> None:
     from .robotframework.server import RobotLanguageServer
 
@@ -38,6 +40,7 @@ def run_server(
         pipe_name=pipe_name,
         profile=profile,
         analysis_config=analysis_config,
+        configuration_errors=configuration_errors,
     ) as server:
         server.run()
 
@@ -76,6 +79,23 @@ def language_server(
 
     profile: Optional[RobotBaseProfile] = None
     analysis_config: Optional[WorkspaceAnalysisConfig] = None
+    # the errors of the configuration go to the log and, once the editor has connected, to the editor
+    configuration_errors: List[str] = []
+
+    def report_error(message: Union[str, Callable[[], Any]]) -> None:
+        text = str(message() if callable(message) else message)
+        configuration_errors.append(text)
+        app.error(text)
+
+    # the editors report a name that they pass with `-p` and that selects no profile themselves, with a way to fix it;
+    # a name from `ROBOTCODE_PROFILES` no editor reports
+    profiles_from_environment = ctx.find_root().get_parameter_source("profiles") == ParameterSource.ENVIRONMENT
+
+    def report_unknown_profile(unknown: UnknownProfile) -> None:
+        if unknown.selected and not profiles_from_environment:
+            app.error(unknown.message)
+        else:
+            report_error(unknown.message)
 
     config_files, root_folder, _ = get_config_files(
         paths,
@@ -98,11 +118,15 @@ def language_server(
 
         analysis_config = analyzer_config.to_workspace_analysis_config()
 
+        # the server starts also when a name selects no profile, with the configuration without that name
         profile = robot_config.combine_profiles(
-            *(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error
-        ).evaluated_with_env(verbose_callback=app.verbose, error_callback=app.error)
+            *(app.config.profiles or []),
+            verbose_callback=app.verbose,
+            error_callback=report_error,
+            unknown_profile_callback=report_unknown_profile,
+        ).evaluated_with_env(verbose_callback=app.verbose, error_callback=report_error)
     except (TypeError, ValueError) as e:
-        app.error(str(e), err=True)
+        report_error(str(e))
 
     mode, port, bind, pipe_name = resolve_server_options(
         ctx, app, mode, port, bind, pipe_name, tcp, socket, stdio, pipe, None
@@ -115,6 +139,7 @@ def language_server(
             pipe_name=pipe_name,
             profile=profile,
             analysis_config=analysis_config,
+            configuration_errors=configuration_errors,
         )
     except SystemExit as e:
         app.verbose(f"Server exited with code {e.code}", err=e.code != 0)

robotcode_language_server-2.9.0.dev51/src/robotcode/language_server/robotframework/parts/documentation_viewer.py

@@ -0,0 +1,127 @@
+import os
+from concurrent.futures import CancelledError
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Sequence, Set, Tuple
+
+from robotcode.core.uri import Uri
+from robotcode.core.utils.dataclasses import CamelSnakeMixin
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.jsonrpc2.protocol import rpc_method
+from robotcode.robot.diagnostics.library_doc import BUILTIN_LIBRARY_NAME, CompleteResult, CompleteResultKind
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+PATH_SEPARATORS = ("/", os.sep)
+
+# Of two equal labels, a module comes before a file and a file before a directory, as in the editor's completion.
+KIND_ORDER = {CompleteResultKind.MODULE_INTERNAL: 0, CompleteResultKind.MODULE: 0, CompleteResultKind.FOLDER: 2}
+
+
+@dataclass(repr=False)
+class CompleteTargetParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    text: str
+
+
+@dataclass(repr=False)
+class TargetCompletion(CamelSnakeMixin):
+    label: str
+    # the name of the `CompleteResultKind`, and its value as the editor's completion shows it
+    kind: str
+    detail: str
+    # the index in the text from which the label replaces it, in UTF-16 code units as the page counts
+    start: int
+
+
+def split_at_last_separator(text: str, separators: Sequence[str]) -> Tuple[Optional[str], int]:
+    """The text up to and with its last separator, or None without one, and the length of that prefix."""
+    index = max(text.rfind(separator) for separator in separators)
+    return (text[: index + 1], index + 1) if index >= 0 else (None, 0)
+
+
+def utf16_length(text: str) -> int:
+    """The length of `text` in UTF-16 code units, as LSP positions count."""
+    return len(text.encode("utf-16-le")) // 2
+
+
+def completion_order(text: str, result: CompleteResult, start: int) -> Tuple[int, str, int, str]:
+    """The order of the editor's completion: first the labels that continue the typed part in the same case, then the
+    others, each by label without regard to case."""
+    same_case = result.label.startswith(text[start:])
+    return (0 if same_case else 1, result.label.lower(), KIND_ORDER.get(result.kind, 1), result.label)
+
+
+class RobotDocumentationViewerPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+
+    @rpc_method(name="robot/documentationViewer/completeTarget", param_type=CompleteTargetParams, threaded=True)
+    @_logger.call
+    def _complete_target(
+        self,
+        workspace_folder_uri: str,
+        text: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> List[TargetCompletion]:
+        # The arguments of an import are not completed, nor a text of dots only, as in the editor.
+        if "::" in text or (text and all(c == "." for c in text)):
+            return []
+
+        folder = Uri(workspace_folder_uri)
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(folder)
+        base_dir = str(folder.to_path())
+
+        results: Set[Tuple[CompleteResult, int]] = set()
+
+        # Libraries are completed as in the editor: a name with a path separator as a path, any other as a module.
+        library_prefix, library_start = split_at_last_separator(
+            text, PATH_SEPARATORS if any(s in text for s in PATH_SEPARATORS) else (".",)
+        )
+        for result in self._completions(imports_manager.complete_library_import, library_prefix, base_dir):
+            results.add((result, library_start))
+        # The editor leaves out BuiltIn, which every file imports already; for the viewer it is a target like any other.
+        if library_prefix is None:
+            results.add((CompleteResult(BUILTIN_LIBRARY_NAME, CompleteResultKind.MODULE_INTERNAL), 0))
+
+        # Resources are looked up in the base directory only for names that start with `.` or a path separator, but
+        # the target field writes paths relative to the workspace folder without `./`.
+        resource_prefix, resource_start = split_at_last_separator(text, PATH_SEPARATORS)
+        resource_names = [resource_prefix]
+        if (
+            resource_prefix is not None
+            and not resource_prefix.startswith((".", *PATH_SEPARATORS))
+            and not Path(resource_prefix).is_absolute()
+        ):
+            resource_names.append(f"./{resource_prefix}")
+        for name in resource_names:
+            for result in self._completions(imports_manager.complete_resource_import, name, base_dir):
+                results.add((result, resource_start))
+
+        matching = [(r, start) for r, start in results if r.label.lower().startswith(text[start:].lower())]
+        matching.sort(key=lambda item: completion_order(text, *item))
+        return [
+            TargetCompletion(result.label, result.kind.name, result.kind.value, utf16_length(text[:start]))
+            for result, start in matching
+        ]
+
+    def _completions(
+        self,
+        complete: Callable[[Optional[str], str], Optional[List[CompleteResult]]],
+        name: Optional[str],
+        base_dir: str,
+    ) -> List[CompleteResult]:
+        # A side that fails, such as on a directory without read permission, leaves the other side's results.
+        try:
+            return complete(name, base_dir) or []
+        except (SystemExit, KeyboardInterrupt, CancelledError):
+            raise
+        except BaseException as e:
+            self._logger.exception(e)
+            return []

{robotcode_language_server-2.8.0.dev670 → robotcode_language_server-2.9.0.dev51}/src/robotcode/language_server/robotframework/protocol.py

@@ -15,7 +15,7 @@ from typing import (
 
 from robotcode.core.event import event
 from robotcode.core.language import LanguageDefinition
-from robotcode.core.lsp.types import InitializeError
+from robotcode.core.lsp.types import InitializeError, MessageType
 from robotcode.core.utils.dataclasses import CamelSnakeMixin, from_dict
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import JsonRPCErrorException, JsonRPCErrors, ProtocolPartDescriptor
@@ -35,6 +35,7 @@ from .parts.debugging_utils import RobotDebuggingUtilsProtocolPart
 from .parts.diagnostics import RobotDiagnosticsProtocolPart
 from .parts.document_highlight import RobotDocumentHighlightProtocolPart
 from .parts.document_symbols import RobotDocumentSymbolsProtocolPart
+from .parts.documentation_viewer import RobotDocumentationViewerPart
 from .parts.documents_cache import DocumentsCachePart
 from .parts.folding_range import RobotFoldingRangeProtocolPart
 from .parts.formatting import RobotFormattingProtocolPart
@@ -121,6 +122,7 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
 
     robot_debugging_utils = ProtocolPartDescriptor(RobotDebuggingUtilsProtocolPart)
     robot_keywords_treeview = ProtocolPartDescriptor(RobotKeywordsTreeViewPart)
+    robot_documentation_viewer = ProtocolPartDescriptor(RobotDocumentationViewerPart)
     robot_project_info = ProtocolPartDescriptor(ProjectInfoPart)
     robot_workspace_symbols = ProtocolPartDescriptor(RobotWorkspaceSymbolsProtocolPart)
 
@@ -159,13 +161,16 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
         server: "RobotLanguageServer",
         profile: Optional[RobotBaseProfile] = None,
         analysis_config: Optional[WorkspaceAnalysisConfig] = None,
+        configuration_errors: Optional[List[str]] = None,
     ):
         super().__init__(server)
         self.robot_profile = profile if profile is not None else RobotBaseProfile()
         self.analysis_config = analysis_config if analysis_config is not None else WorkspaceAnalysisConfig()
+        self.configuration_errors = configuration_errors if configuration_errors is not None else []
         self.robot_initialization_options = RobotInitializationOptions()
         self.on_initialize.add(self._on_initialize)
         self.on_initialized.add(self.server_initialized)
+        self.on_initialized.add(self.show_configuration_errors)
         self._documents_cache: Optional[DocumentsCachePart] = None
 
     @_logger.call
@@ -223,6 +228,11 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     @event
     def on_robot_initialized(sender) -> None: ...
 
+    # the errors of the configuration that the start loaded, which the editors otherwise show only in the server's log
+    def show_configuration_errors(self, sender: Any) -> None:
+        for message in self.configuration_errors:
+            self.window.show_message(message, MessageType.ERROR)
+
     def server_initialized(self, sender: Any) -> None:
         for folder in self.workspace.workspace_folders:
             for p in self.robot_profile.python_path or []:

{robotcode_language_server-2.8.0.dev670 → robotcode_language_server-2.9.0.dev51}/src/robotcode/language_server/robotframework/server.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import List, Optional
 
 from robotcode.core.types import ServerMode, TcpParams
 from robotcode.language_server.common.server import (
@@ -19,10 +19,12 @@ class RobotLanguageServer(LanguageServerBase[RobotLanguageServerProtocol]):
         pipe_name: Optional[str] = None,
         profile: Optional[RobotBaseProfile] = None,
         analysis_config: Optional[WorkspaceAnalysisConfig] = None,
+        configuration_errors: Optional[List[str]] = None,
     ):
         super().__init__(mode, tcp_params, pipe_name)
         self.profile = profile
         self.analysis_config = analysis_config
+        self.configuration_errors = configuration_errors
 
     def create_protocol(self) -> RobotLanguageServerProtocol:
-        return RobotLanguageServerProtocol(self, self.profile, self.analysis_config)
+        return RobotLanguageServerProtocol(self, self.profile, self.analysis_config, self.configuration_errors)

robotcode_language_server-2.8.0.dev670/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.8.0-dev.670"