robotcode-language-server 1.3.0.dev5__tar.gz → 1.4.0__tar.gz

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-language-server
-Version: 1.3.0.dev5
+Version: 1.4.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==1.3.0-dev.5
-Requires-Dist: robotcode-jsonrpc2==1.3.0-dev.5
-Requires-Dist: robotcode-robot==1.3.0-dev.5
-Requires-Dist: robotcode==1.3.0-dev.5
+Requires-Dist: robotcode-analyze==1.4.0
+Requires-Dist: robotcode-jsonrpc2==1.4.0
+Requires-Dist: robotcode-robot==1.4.0
+Requires-Dist: robotcode==1.4.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/pyproject.toml

@@ -27,10 +27,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==1.3.0-dev.5",
-  "robotcode-robot==1.3.0-dev.5",
-  "robotcode-analyze==1.3.0-dev.5",
-  "robotcode==1.3.0-dev.5",
+  "robotcode-jsonrpc2==1.4.0",
+  "robotcode-robot==1.4.0",
+  "robotcode-analyze==1.4.0",
+  "robotcode==1.4.0",
 ]
 dynamic = ["version"]
 

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

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

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/common/parts/diagnostics.py

@@ -1,7 +1,6 @@
 import concurrent.futures
 import functools
 import itertools
-import logging
 import time
 import uuid
 from concurrent.futures import CancelledError
@@ -361,7 +360,6 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                 with self._logger.measure_time(
                     lambda: f"analyzing workspace for {len(documents)} documents",
                     context_name="workspace_diagnostics",
-                    level=logging.CRITICAL,
                 ):
                     self.on_workspace_diagnostics_analyze(self)
 
@@ -444,7 +442,6 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                 with self._logger.measure_time(
                     lambda: f"collect workspace diagnostic for {len(documents_to_collect)} documents",
                     context_name="collect_workspace_diagnostics",
-                    level=logging.CRITICAL,
                 ):
                     breaked = False
                     for document in set(documents) - set(documents_to_collect):

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/common/parts/workspace.py

@@ -315,7 +315,7 @@ class Workspace(LanguageServerProtocolPart, CoreWorkspace, FileWatcherManagerBas
                 List[Any],
             )
 
-        result = self.settings
+        result: Any = self.settings
         for sub_key in str(section).split("."):
             if sub_key in result:
                 result = result.get(sub_key, None)

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/common/protocol.py

@@ -98,15 +98,6 @@ class LanguageServerLogHandler(logging.Handler):
             if self.trace != TraceValues.OFF:
                 self.protocol.log_trace(record.getMessage())
 
-        type = self.MAPPING.get(record.levelno, None)
-        if type is None:
-            type = MessageType.LOG
-
-        self.protocol.window_log_message(
-            type=type,
-            message=record.getMessage(),
-        )
-
 
 class LanguageServerProtocol(JsonRPCProtocol):
     __logger = LoggingDescriptor()

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -17,13 +17,12 @@ from robotcode.robot.utils import get_robot_version
 
 from ..configuration import RoboCopConfig, RoboTidyConfig
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -31,7 +30,9 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
 
         parent.formatting.format.add(self.format)
 
-        if self.robotidy_installed or (self.robocop_installed and self.robocop_version >= (6, 0)):
+        if self.parent.robocop_helper.robotidy_installed or (
+            self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0)
+        ):
             parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
@@ -64,8 +65,8 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        if (get_robot_version() >= (5, 0)) and self.robocop_installed and self.robocop_version >= (6, 0):
-            if not self.is_robocop_notification_shown and self.robotidy_installed:
+        if self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0):
+            if not self.is_robocop_notification_shown and self.parent.robocop_helper.robotidy_installed:
                 self.parent.window.show_message(
                     "`robotframework-robocop >= 6.0` is installed and will be used for formatting.\n\n"
                     "`robotframework-tidy` is also detected in the workspace, but its use is redundant.\n"
@@ -78,7 +79,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
             return self.format_robocop(document, options, **further_options)
 
         tidy_config = self.get_tidy_config(document)
-        if (tidy_config.enabled or get_robot_version() >= (5, 0)) and self.robotidy_installed:
+        if (tidy_config.enabled or get_robot_version() >= (5, 0)) and self.parent.robocop_helper.robotidy_installed:
             return self.format_robot_tidy(document, options, config=tidy_config, **further_options)
 
         if get_robot_version() < (5, 0):
@@ -105,18 +106,18 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
 
             model = self.parent.documents_cache.get_model(document, False)
 
-            if self.robotidy_version >= (3, 0):
+            if self.parent.robocop_helper.robotidy_version >= (3, 0):
                 from robotidy.api import get_robotidy
                 from robotidy.disablers import RegisterDisablers
 
-                if self.robotidy_version >= (4, 2):
+                if self.parent.robocop_helper.robotidy_version >= (4, 2):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
                         ignore_git_dir=config.ignore_git_dir,
                         config=config.config,
                     )
-                elif self.robotidy_version >= (4, 1):
+                elif self.parent.robocop_helper.robotidy_version >= (4, 1):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
@@ -135,14 +136,14 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
                 )
                 disabler_finder.visit(model)
 
-                if self.robotidy_version >= (4, 11):
+                if self.parent.robocop_helper.robotidy_version >= (4, 11):
                     if disabler_finder.is_disabled_in_file():
                         return None
                 else:
                     if disabler_finder.file_disabled:
                         return None
 
-                if self.robotidy_version >= (4, 0):
+                if self.parent.robocop_helper.robotidy_version >= (4, 0):
                     _, _, new, _ = robot_tidy.transform_until_stable(model, disabler_finder)
                 else:
                     _, _, new = robot_tidy.transform(model, disabler_finder.disablers)
@@ -156,7 +157,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
                     robot_tidy.formatting_config.start_line = range.start.line + 1
                     robot_tidy.formatting_config.end_line = range.end.line + 1
 
-                if self.robotidy_version >= (2, 2):
+                if self.parent.robocop_helper.robotidy_version >= (2, 2):
                     from robotidy.disablers import RegisterDisablers
 
                     disabler_finder = RegisterDisablers(
@@ -197,17 +198,13 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         range: Optional[Range] = None,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        from robocop.config import ConfigManager
         from robocop.formatter.runner import RobocopFormatter
 
-        robocop_config = self.get_robocop_config(document)
+        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if workspace_folder is None:
+            return None
 
-        config_manager = ConfigManager(
-            [document.uri.to_path()],
-            config=robocop_config.config_file,
-            ignore_git_dir=robocop_config.ignore_git_dir,
-            ignore_file_config=robocop_config.ignore_file_config,
-        )
+        config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
 
         config = config_manager.get_config_for_source_file(document.uri.to_path())
 
@@ -282,7 +279,9 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
         config = self.get_tidy_config(document)
-        if (config.enabled and self.robotidy_installed) or (self.robocop_installed and self.robocop_version >= (6, 0)):
+        if (config.enabled and self.parent.robocop_helper.robotidy_installed) or (
+            self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0)
+        ):
             return self.format_robot_tidy(document, options, range=range, config=config, **further_options)
 
         return None

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/hover.py

@@ -73,7 +73,7 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_HoverMethod, method)
+                return method
 
         return None
 

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/inlay_hint.py

@@ -61,7 +61,7 @@ class RobotInlayHintProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_HandlerMethod, method)
+                return method
 
         return None
 

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -10,7 +10,6 @@ from robotcode.jsonrpc2.protocol import rpc_method
 
 from ...__version__ import __version__ as robotcode_version
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -26,7 +25,7 @@ class ProjectInfo(CamelSnakeMixin):
     robot_code_version_string: Optional[str] = None
 
 
-class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class ProjectInfoPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -40,12 +39,12 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
         **kwargs: Any,
     ) -> ProjectInfo:
         robocop_version_string = None
-        if self.robocop_installed:
-            robocop_version_string = self.robocop_version_str
+        if self.parent.robocop_helper.robocop_installed:
+            robocop_version_string = self.parent.robocop_helper.robocop_version_str
 
         tidy_version_string = None
-        if self.robotidy_installed:
-            tidy_version_string = self.robotidy_version_str
+        if self.parent.robocop_helper.robotidy_installed:
+            tidy_version_string = self.parent.robocop_helper.robotidy_version_str
 
         return ProjectInfo(
             robot_version_string=get_version(),

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/references.py

@@ -113,7 +113,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_ReferencesMethod, method)
+                return method
         return None
 
     @language_id("robotframework")

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -1,5 +1,6 @@
 import io
 from typing import TYPE_CHECKING, Any, List, Optional
+from weakref import WeakKeyDictionary
 
 from robotcode.core.language import language_id
 from robotcode.core.lsp.types import (
@@ -17,21 +18,23 @@ from robotcode.core.workspace import WorkspaceFolder
 from ...common.parts.diagnostics import DiagnosticsCollectType, DiagnosticsResult
 from ..configuration import RoboCopConfig
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
+    from robocop.linter.runner import RobocopLinter
+
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
         super().__init__(parent)
 
         self.source_name = "robocop"
+        self._robocop_linters: WeakKeyDictionary[WorkspaceFolder, "RobocopLinter"] = WeakKeyDictionary()
 
-        if self.robocop_installed and self.robocop_version < (6, 0):
+        if self.parent.robocop_helper.robocop_installed:
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:
@@ -45,21 +48,80 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
     @_logger.call
     def collect_diagnostics(
         self, sender: Any, document: TextDocument, diagnostics_type: DiagnosticsCollectType
-    ) -> DiagnosticsResult:
-        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
-        if workspace_folder is not None:
-            extension_config = self.get_config(document)
-
-            if extension_config is not None and extension_config.enabled:
-                return DiagnosticsResult(
-                    self.collect_diagnostics,
-                    self.collect(document, workspace_folder, extension_config),
-                )
+    ) -> Optional[DiagnosticsResult]:
+        if self.parent.robocop_helper.robocop_installed:
+            workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+            if workspace_folder is not None:
+                config = self.get_config(document)
+
+                if config is not None and config.enabled:
+                    if self.parent.robocop_helper.robocop_version >= (6, 0):
+                        # In Robocop 6.0, the diagnostics are collected in a different way
+                        return DiagnosticsResult(self.collect_diagnostics, self.collect(document, workspace_folder))
+
+                    return DiagnosticsResult(
+                        self.collect_diagnostics,
+                        self.collect_old(document, workspace_folder, config),
+                    )
+
+        return None
+
+    @_logger.call
+    def collect(self, document: TextDocument, workspace_folder: WorkspaceFolder) -> List[Diagnostic]:
+        from robocop.linter.rules import RuleSeverity
+        from robocop.linter.runner import RobocopLinter
+
+        linter = self._robocop_linters.get(workspace_folder, None)
+
+        if linter is None:
+            config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
+
+            config = config_manager.get_config_for_source_file(document.uri.to_path())
 
-        return DiagnosticsResult(self.collect_diagnostics, [])
+            linter = RobocopLinter(config_manager)
+            self._robocop_linters[workspace_folder] = linter
+
+        source = document.uri.to_path()
+
+        config = linter.config_manager.get_config_for_source_file(source)
+        model = self.parent.documents_cache.get_model(document, False)
+        diagnostics = linter.run_check(model, source, config)
+
+        return [
+            Diagnostic(
+                range=Range(
+                    start=Position(
+                        line=diagnostic.range.start.line - 1,
+                        character=diagnostic.range.start.character - 1,
+                    ),
+                    end=Position(
+                        line=max(0, diagnostic.range.end.line - 1),
+                        character=max(0, diagnostic.range.end.character - 1),
+                    ),
+                ),
+                message=diagnostic.message,
+                severity=(
+                    DiagnosticSeverity.INFORMATION
+                    if diagnostic.severity == RuleSeverity.INFO
+                    else (
+                        DiagnosticSeverity.WARNING
+                        if diagnostic.severity == RuleSeverity.WARNING
+                        else (
+                            DiagnosticSeverity.ERROR
+                            if diagnostic.severity == RuleSeverity.ERROR
+                            else DiagnosticSeverity.HINT
+                        )
+                    )
+                ),
+                source=self.source_name,
+                code=f"{diagnostic.rule.rule_id}-{diagnostic.rule.name}",
+                code_description=self.get_code_description(self.parent.robocop_helper.robocop_version, diagnostic),
+            )
+            for diagnostic in diagnostics
+        ]
 
     @_logger.call
-    def collect(
+    def collect_old(
         self,
         document: TextDocument,
         workspace_folder: WorkspaceFolder,
@@ -174,7 +236,9 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
         if version < (3, 0):
             return None
 
-        base = f"https://robocop.readthedocs.io/en/{version.major}.{version.minor}.{version.patch}"
+        version_letter = "v" if version.major >= 6 else ""
+
+        base = f"https://robocop.readthedocs.io/en/{version_letter}{version.major}.{version.minor}.{version.patch}"
 
         if version < (4, 0):
             return CodeDescription(href=f"{base}/rules.html#{issue.name}".lower())
@@ -187,4 +251,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
                 href=f"{base}/rules_list.html#{issue.name}-{issue.severity.value}{issue.rule_id}".lower()
             )
 
-        return CodeDescription(href=f"{base}/rules_list.html#{issue.name}".lower())
+        if version < (6, 0):
+            return CodeDescription(href=f"{base}/rules_list.html#{issue.name}".lower())
+
+        return CodeDescription(href=f"{base}/rules/rules_list.html#{issue.rule.rule_id}-{issue.rule.name}".lower())

robotcode_language_server-1.4.0/src/robotcode/language_server/robotframework/parts/robocop_helper.py

@@ -0,0 +1,117 @@
+import functools
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, Union
+
+from robotcode.core.lsp.types import MessageType
+from robotcode.core.text_document import TextDocument
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.core.utils.version import Version, create_version_from_str
+from robotcode.core.workspace import WorkspaceFolder
+
+from ..configuration import RoboCopConfig
+from .protocol_part import RobotLanguageServerProtocolPart
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+if TYPE_CHECKING:
+    from robocop.config import ConfigManager
+
+
+class RobocopConfigError(Exception):
+    """Robocop configuration errors."""
+
+
+class RoboCopHelper(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+        self._config_managers: Dict[WorkspaceFolder, "ConfigManager"] = {}
+
+    @functools.cached_property
+    def robotidy_installed(self) -> bool:
+        try:
+            __import__("robotidy")
+        except ImportError:
+            return False
+        return True
+
+    @functools.cached_property
+    def robotidy_version(self) -> Version:
+        from robotidy.version import __version__
+
+        return create_version_from_str(__version__)
+
+    @functools.cached_property
+    def robotidy_version_str(self) -> str:
+        from robotidy.version import __version__
+
+        return str(__version__)
+
+    @functools.cached_property
+    def robocop_installed(self) -> bool:
+        try:
+            __import__("robocop")
+        except ImportError:
+            return False
+        return True
+
+    @functools.cached_property
+    def robocop_version(self) -> Version:
+        from robocop import __version__
+
+        return create_version_from_str(__version__)
+
+    @functools.cached_property
+    def robocop_version_str(self) -> str:
+        from robocop import __version__
+
+        return str(__version__)
+
+    def get_robocop_config(self, resource: Union[TextDocument, WorkspaceFolder]) -> RoboCopConfig:
+        folder = (
+            self.parent.workspace.get_workspace_folder(resource.uri) if isinstance(resource, TextDocument) else resource
+        )
+        if folder is None:
+            return RoboCopConfig()
+
+        return self.parent.workspace.get_configuration(RoboCopConfig, folder.uri)
+
+    def get_config_manager(self, workspace_folder: WorkspaceFolder) -> "ConfigManager":
+        from robocop.config import ConfigManager
+
+        if workspace_folder in self._config_managers:
+            return self._config_managers[workspace_folder]
+
+        config = self.get_robocop_config(workspace_folder)
+
+        result = None
+        try:
+            config_path = None
+
+            if config.config_file:
+                config_path = Path(config.config_file)
+                if not config_path.exists():
+                    raise RobocopConfigError(f"Config file {config_path} does not exist.")
+
+            result = ConfigManager(
+                [],
+                root=workspace_folder.uri.to_path(),
+                config=config_path,
+                ignore_git_dir=config.ignore_git_dir,
+                ignore_file_config=config.ignore_file_config,
+            )
+            self._config_managers[workspace_folder] = result
+            return result
+        except Exception as e:
+            self._logger.exception(e)
+            e_msg = str(e)
+            error_details = f": {e_msg}" if e_msg else ""
+            self.parent.window.show_message(
+                f"Robocop configuration could not be loaded{error_details}. "
+                f"Please verify your configuration files "
+                f"and workspace settings. Check the output logs for detailed error information.",
+                MessageType.ERROR,
+            )
+            raise RobocopConfigError(f"Failed to load Robocop configuration: {e} ({e.__class__.__qualname__})") from e

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/parts/signature_help.py

@@ -68,7 +68,7 @@ class RobotSignatureHelpProtocolPart(RobotLanguageServerProtocolPart, ModelHelpe
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_SignatureHelpMethod, method)
+                return method
         return None
 
     @language_id("robotframework")

{robotcode_language_server-1.3.0.dev5 → robotcode_language_server-1.4.0}/src/robotcode/language_server/robotframework/protocol.py

@@ -48,6 +48,7 @@ from .parts.project_info import ProjectInfoPart
 from .parts.references import RobotReferencesProtocolPart
 from .parts.rename import RobotRenameProtocolPart
 from .parts.robocop_diagnostics import RobotRoboCopDiagnosticsProtocolPart
+from .parts.robocop_helper import RoboCopHelper
 from .parts.robot_workspace import RobotWorkspaceProtocolPart
 from .parts.selection_range import RobotSelectionRangeProtocolPart
 from .parts.semantic_tokens import RobotSemanticTokenProtocolPart
@@ -102,6 +103,7 @@ class RobotLanguageServerProtocol(LanguageServerProtocol):
     robot_completion = ProtocolPartDescriptor(RobotCompletionProtocolPart)
     robot_signature_help = ProtocolPartDescriptor(RobotSignatureHelpProtocolPart)
     robot_document_symbols = ProtocolPartDescriptor(RobotDocumentSymbolsProtocolPart)
+    robocop_helper = ProtocolPartDescriptor(RoboCopHelper)
     robot_robocop_diagnostics = ProtocolPartDescriptor(RobotRoboCopDiagnosticsProtocolPart)
     robot_formatting = ProtocolPartDescriptor(RobotFormattingProtocolPart)
     robot_semantic_tokens = ProtocolPartDescriptor(RobotSemanticTokenProtocolPart)

robotcode_language_server-1.3.0.dev5/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "1.3.0-dev.5"

robotcode_language_server-1.3.0.dev5/src/robotcode/language_server/robotframework/parts/robocop_tidy_mixin.py

@@ -1,49 +0,0 @@
-import functools
-
-from robotcode.core.utils.version import Version, create_version_from_str
-
-
-class RoboCopTidyMixin:
-    """
-    Mixin class for handling Robocop tidy operations.
-    """
-
-    @functools.cached_property
-    def robotidy_installed(self) -> bool:
-        try:
-            __import__("robotidy")
-        except ImportError:
-            return False
-        return True
-
-    @functools.cached_property
-    def robotidy_version(self) -> Version:
-        from robotidy.version import __version__
-
-        return create_version_from_str(__version__)
-
-    @functools.cached_property
-    def robotidy_version_str(self) -> str:
-        from robotidy.version import __version__
-
-        return str(__version__)
-
-    @functools.cached_property
-    def robocop_installed(self) -> bool:
-        try:
-            __import__("robocop")
-        except ImportError:
-            return False
-        return True
-
-    @functools.cached_property
-    def robocop_version(self) -> Version:
-        from robocop import __version__
-
-        return create_version_from_str(__version__)
-
-    @functools.cached_property
-    def robocop_version_str(self) -> str:
-        from robocop import __version__
-
-        return str(__version__)