robotcode-language-server 1.3.0.dev2__tar.gz → 1.3.0.dev3__tar.gz

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev3}/PKG-INFO

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

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev3}/pyproject.toml

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

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

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

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev3}/src/robotcode/language_server/robotframework/configuration.py

@@ -33,6 +33,9 @@ class RoboCopConfig(ConfigBase):
     enabled: bool = True
     include: List[str] = field(default_factory=list)
     exclude: List[str] = field(default_factory=list)
+    ignore_git_dir: bool = False
+    ignore_file_config: bool = False
+    config_file: Optional[str] = None
     configurations: List[str] = field(default_factory=list)
 
 

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev3}/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -1,6 +1,5 @@
 import io
 import os
-import re
 from concurrent.futures import CancelledError
 from typing import TYPE_CHECKING, Any, List, Optional, cast
 
@@ -14,26 +13,17 @@ from robotcode.core.lsp.types import (
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.core.utils.version import create_version_from_str
-from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.utils import get_robot_version
 
-from ..configuration import RoboTidyConfig
+from ..configuration import RoboCopConfig, RoboTidyConfig
 from .protocol_part import RobotLanguageServerProtocolPart
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-def robotidy_installed() -> bool:
-    try:
-        __import__("robotidy")
-    except ImportError:
-        return False
-    return True
-
-
-class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -41,7 +31,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         parent.formatting.format.add(self.format)
 
-        if robotidy_installed():
+        if self.robotidy_installed or (self.robocop_installed and self.robocop_version >= (6, 0)):
             parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
@@ -49,14 +39,22 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         self.line_separator = os.linesep
         self.short_test_name_length = 18
         self.setting_and_variable_name_length = 14
+        self.robocop_installed_message_shown = False
 
-    def get_config(self, document: TextDocument) -> RoboTidyConfig:
+    def get_tidy_config(self, document: TextDocument) -> RoboTidyConfig:
         folder = self.parent.workspace.get_workspace_folder(document.uri)
         if folder is None:
             return RoboTidyConfig()
 
         return self.parent.workspace.get_configuration(RoboTidyConfig, folder.uri)
 
+    def get_robocop_config(self, document: TextDocument) -> RoboCopConfig:
+        folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if folder is None:
+            return RoboCopConfig()
+
+        return self.parent.workspace.get_configuration(RoboCopConfig, folder.uri)
+
     @language_id("robotframework")
     @_logger.call
     def format(
@@ -66,23 +64,32 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = self.get_config(document)
+        if (get_robot_version() >= (5, 0)) and self.robocop_installed and self.robocop_version >= (6, 0):
+            if not self.robocop_installed_message_shown and self.robotidy_installed:
+                self.parent.window.show_message(
+                    "`robotframework-robocop >= 6.0` is installed and will be used for formatting.\n"
+                    "`robotframework-tidy` is also detected in the workspace. "
+                    "It is not needed as `robocop` handles formatting tasks.\n",
+                    MessageType.INFO,
+                )
+                self.robocop_installed_message_shown = True
 
-        if (config.enabled or get_robot_version() >= (5, 0)) and robotidy_installed():
-            return self.format_robot_tidy(document, options, config=config, **further_options)
+            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:
+            return self.format_robot_tidy(document, options, config=tidy_config, **further_options)
 
         if get_robot_version() < (5, 0):
             return self.format_internal(document, options, **further_options)
 
         self.parent.window.show_message(
-            "RobotFramework formatter is not available, please install 'robotframework-tidy'.",
+            "RobotFramework formatter is not available, please install 'robotframework-robocop'.",
             MessageType.ERROR,
         )
 
         return None
 
-    RE_LINEBREAKS = re.compile(r"\r\n|\r|\n")
-
     def format_robot_tidy(
         self,
         document: TextDocument,
@@ -91,28 +98,24 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         config: Optional[RoboTidyConfig] = None,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        from robotidy.version import __version__
-
         try:
             if config is None:
-                config = self.get_config(document)
-
-            robotidy_version = create_version_from_str(__version__)
+                config = self.get_tidy_config(document)
 
             model = self.parent.documents_cache.get_model(document, False)
 
-            if robotidy_version >= (3, 0):
+            if self.robotidy_version >= (3, 0):
                 from robotidy.api import get_robotidy
                 from robotidy.disablers import RegisterDisablers
 
-                if robotidy_version >= (4, 2):
+                if self.robotidy_version >= (4, 2):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
                         ignore_git_dir=config.ignore_git_dir,
                         config=config.config,
                     )
-                elif robotidy_version >= (4, 1):
+                elif self.robotidy_version >= (4, 1):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
@@ -131,14 +134,14 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                 )
                 disabler_finder.visit(model)
 
-                if robotidy_version >= (4, 11):
+                if self.robotidy_version >= (4, 11):
                     if disabler_finder.is_disabled_in_file():
                         return None
                 else:
                     if disabler_finder.file_disabled:
                         return None
 
-                if robotidy_version >= (4, 0):
+                if self.robotidy_version >= (4, 0):
                     _, _, new, _ = robot_tidy.transform_until_stable(model, disabler_finder)
                 else:
                     _, _, new = robot_tidy.transform(model, disabler_finder.disablers)
@@ -152,7 +155,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                     robot_tidy.formatting_config.start_line = range.start.line + 1
                     robot_tidy.formatting_config.end_line = range.end.line + 1
 
-                if robotidy_version >= (2, 2):
+                if self.robotidy_version >= (2, 2):
                     from robotidy.disablers import RegisterDisablers
 
                     disabler_finder = RegisterDisablers(
@@ -186,6 +189,50 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             self.parent.window.show_message(f"Executing `robotidy` failed: {e}", MessageType.ERROR)
         return None
 
+    def format_robocop(
+        self,
+        document: TextDocument,
+        options: FormattingOptions,
+        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)
+
+        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 = config_manager.get_config_for_source_file(document.uri.to_path())
+
+        if range is not None:
+            config.formatter.start_line = range.start.line + 1
+            config.formatter.end_line = range.end.line + 1
+
+        runner = RobocopFormatter(config_manager)
+        runner.config = config
+
+        model = self.parent.documents_cache.get_model(document, False)
+        _, _, new, _ = runner.format_until_stable(model)
+
+        if new.text == document.text():
+            return None
+
+        return [
+            TextEdit(
+                range=Range(
+                    start=Position(line=0, character=0),
+                    end=Position(line=len(document.get_lines()), character=0),
+                ),
+                new_text=new.text,
+            )
+        ]
+
     def format_internal(
         self,
         document: TextDocument,
@@ -233,8 +280,8 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = self.get_config(document)
-        if config.enabled and robotidy_installed():
+        config = self.get_tidy_config(document)
+        if (config.enabled and self.robotidy_installed) or (self.robocop_installed and self.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.dev2 → robotcode_language_server-1.3.0.dev3}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -7,9 +7,8 @@ from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 
-from .formatting import robotidy_installed
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_diagnostics import robocop_installed
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -22,7 +21,7 @@ class ProjectInfo(CamelSnakeMixin):
     tidy_version_string: Optional[str] = None
 
 
-class ProjectInfoPart(RobotLanguageServerProtocolPart):
+class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -36,24 +35,12 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart):
         **kwargs: Any,
     ) -> ProjectInfo:
         robocop_version_string = None
-        if robocop_installed():
-            try:
-                from robocop.version import __version__
-
-                robocop_version_string = __version__
-            except ImportError:
-                try:
-                    from robocop import __version__
-
-                    robocop_version_string = __version__
-                except ImportError:
-                    pass
+        if self.robocop_installed:
+            robocop_version_string = self.robocop_version_str
 
         tidy_version_string = None
-        if robotidy_installed():
-            from robotidy.version import __version__
-
-            tidy_version_string = __version__
+        if self.robotidy_installed:
+            tidy_version_string = self.robotidy_version_str
 
         return ProjectInfo(
             robot_version_string=get_version(),

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev3}/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -17,20 +17,13 @@ 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 ..protocol import RobotLanguageServerProtocol
 
 
-def robocop_installed() -> bool:
-    try:
-        __import__("robocop")
-    except ImportError:
-        return False
-    return True
-
-
-class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
+class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -38,7 +31,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
 
         self.source_name = "robocop"
 
-        if robocop_installed():
+        if self.robocop_installed and self.robocop_version < (6, 0):
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:

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

@@ -0,0 +1,49 @@
+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__)

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

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