feat(langserver): improve and unify Robocop 6 configuration loading

- Enhance configuration loading process
- Add notifications for faulty configurations

closes #469

Author: d-biehl

packages/language_server/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -17,21 +17,22 @@
 
 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:
         super().__init__(parent)
 
         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 @@ def format(
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        if 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 @@ def format(
             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 @@ def format_robot_tidy(
 
             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 @@ def format_robot_tidy(
                 )
                 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 @@ def format_robot_tidy(
                     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,19 +198,13 @@ def format_robocop(
         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()],
-            root=workspace_folder.uri.to_path() if workspace_folder else None,
-            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())
 
@@ -284,7 +279,9 @@ def format_range(
         **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

packages/language_server/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -10,7 +10,6 @@
 
 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 @@ def _robot_project_info(
         **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(),

packages/language_server/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -18,15 +18,14 @@
 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:
@@ -35,7 +34,7 @@ def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
         self.source_name = "robocop"
         self._robocop_linters: WeakKeyDictionary[WorkspaceFolder, "RobocopLinter"] = WeakKeyDictionary()
 
-        if self.robocop_installed:
+        if self.parent.robocop_helper.robocop_installed:
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:
@@ -50,18 +49,15 @@ def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:
     def collect_diagnostics(
         self, sender: Any, document: TextDocument, diagnostics_type: DiagnosticsCollectType
     ) -> Optional[DiagnosticsResult]:
-        if self.robocop_installed:
+        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.robocop_version >= (6, 0):
+                    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, config),
-                        )
+                        return DiagnosticsResult(self.collect_diagnostics, self.collect(document, workspace_folder))
 
                     return DiagnosticsResult(
                         self.collect_diagnostics,
@@ -71,26 +67,17 @@ def collect_diagnostics(
         return None
 
     @_logger.call
-    def collect(
-        self,
-        document: TextDocument,
-        workspace_folder: WorkspaceFolder,
-        extension_config: RoboCopConfig,
-    ) -> List[Diagnostic]:
-        from robocop.config import ConfigManager
+    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 = ConfigManager(
-                [],
-                root=workspace_folder.uri.to_path(),
-                config=extension_config.config_file,
-                ignore_git_dir=extension_config.ignore_git_dir,
-                ignore_file_config=extension_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())
+
             linter = RobocopLinter(config_manager)
             self._robocop_linters[workspace_folder] = linter
 
@@ -128,7 +115,7 @@ def collect(
                 ),
                 source=self.source_name,
                 code=f"{diagnostic.rule.rule_id}-{diagnostic.rule.name}",
-                code_description=self.get_code_description(self.robocop_version, diagnostic),
+                code_description=self.get_code_description(self.parent.robocop_helper.robocop_version, diagnostic),
             )
             for diagnostic in diagnostics
         ]

packages/language_server/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