integrate robotframework-tidy for formatting, closes #6

Author: d-biehl

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
+### added
+
+- integrate robotframework-tidy for formatting
+
 ## 0.2.1
 
 ### added

package.json

@@ -206,12 +206,6 @@
             "description": "Default setting for where to launch the debug target: internal console, integrated terminal, or external terminal.",
             "scope": "resource"
           },
-          "robotcode.robocop.enabled": {
-            "type": "boolean",
-            "default": true,
-            "description": "Enables 'robocop' code analysis, if installed.",
-            "scope": "resource"
-          },
           "robotcode.syntax.sectionStyle": {
             "type": "string",
             "default": "*** {name}s ***",
@@ -224,6 +218,12 @@
             "description": "Defines if the test report should be opened a run session automatically.",
             "scope": "resource"
           },
+          "robotcode.robocop.enabled": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Enables 'robocop' code analysis, if installed. See [robocop](https://github.com/MarketSquare/robotframework-robocop)",
+            "scope": "resource"
+          },
           "robotcode.robocop.include": {
             "type": "array",
             "default": [],
@@ -250,6 +250,12 @@
             },
             "description": "Configure 'robocop' checker with parameter value.",
             "scope": "resource"
+          },
+          "robotcode.robotidy.enabled": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Enables 'robotidy' code formatting, if installed. See [robotidy](https://github.com/MarketSquare/robotframework-tidy)",
+            "scope": "resource"
           }
         }
       }

pyproject.toml

@@ -27,6 +27,7 @@ coloredlogs = "^15.0.1"
 robotremoteserver = "^1.1"
 Cython = "^0.29.24"
 robotframework-robocop = "^1.7.1"
+robotframework-tidy = "^1.5.1"
 
 
 [tool.poetry-dynamic-versioning]

robotcode/language_server/common/parts/formatting.py

@@ -13,6 +13,7 @@
     DocumentFormattingOptions,
     DocumentFormattingParams,
     DocumentRangeFormattingOptions,
+    DocumentRangeFormattingParams,
     FormattingOptions,
     ProgressToken,
     Range,
@@ -84,11 +85,12 @@ async def _text_document_formatting(
 
         return None
 
-    @rpc_method(name="textDocument/rangeFormatting", param_type=DocumentFormattingParams)
+    @rpc_method(name="textDocument/rangeFormatting", param_type=DocumentRangeFormattingParams)
     async def _text_document_range_formatting(
         self,
         params: DocumentFormattingParams,
         text_document: TextDocumentIdentifier,
+        range: Range,
         options: FormattingOptions,
         work_done_token: Optional[ProgressToken],
         *args: Any,

robotcode/language_server/robotframework/configuration.py

@@ -31,6 +31,11 @@ class RoboCopConfig(ConfigBase):
     configurations: List[str]
 
 
+@config_section("robotcode.robotidy")
+class RoboTidyConfig(ConfigBase):
+    enabled: bool
+
+
 @config_section("robotcode")
 class RobotCodeConfig(ConfigBase):
     language_server: LanguageServerConfig

robotcode/language_server/robotframework/parts/formatting.py

@@ -7,34 +7,111 @@
 from ....utils.logging import LoggingDescriptor
 from ...common.language import language_id
 from ...common.text_document import TextDocument
-from ...common.types import FormattingOptions, Position, Range, TextEdit
+from ...common.types import FormattingOptions, MessageType, Position, Range, TextEdit
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
+from ..configuration import RoboTidyConfig
 from .model_helper import ModelHelperMixin
 from .protocol_part import RobotLanguageServerProtocolPart
 
 
+def robotidy_installed() -> bool:
+    try:
+        __import__("robotidy")
+    except ImportError:
+        return False
+    return True
+
+
 class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
 
         parent.formatting.format.add(self.format)
-        parent.formatting.format_range.add(self.format_range)
+        # TODO implement range formatting
+        # parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
         self.use_pipes = False
         self.line_separator = os.linesep
         self.short_test_name_length = 18
         self.setting_and_variable_name_length = 14
 
+    async def get_config(self, document: TextDocument) -> Optional[RoboTidyConfig]:
+        folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if folder is None:
+            return None
+
+        return await self.parent.workspace.get_configuration(RoboTidyConfig, folder.uri)
+
     @language_id("robotframework")
     async def format(
         self, sender: Any, document: TextDocument, options: FormattingOptions, **further_options: Any
     ) -> Optional[List[TextEdit]]:
+        config = await self.get_config(document)
+        if config and config.enabled and robotidy_installed():
+            return await self.format_robot_tidy(document, options, **further_options)
+        return await self.format_internal(document, options, **further_options)
+
+    async def format_robot_tidy(
+        self, document: TextDocument, options: FormattingOptions, **further_options: Any
+    ) -> Optional[List[TextEdit]]:
+
+        from difflib import SequenceMatcher
+
+        from robotidy.api import RobotidyAPI
+
+        try:
+            model = await self.parent.documents_cache.get_model(document)
+
+            robot_tidy = RobotidyAPI(document.uri.to_path(), None)
+
+            changed, _, new = robot_tidy.transform(model)
+
+            if not changed:
+                return None
+
+            new_lines = new.text.splitlines()
+
+            result: List[TextEdit] = []
+            matcher = SequenceMatcher(a=document.lines, b=new_lines, autojunk=False)
+            for code, old_start, old_end, new_start, new_end in matcher.get_opcodes():
+                if code == "insert" or code == "replace":
+                    result.append(
+                        TextEdit(
+                            range=Range(
+                                start=Position(line=old_start, character=0),
+                                end=Position(line=old_end, character=0),
+                            ),
+                            new_text=os.linesep.join(new_lines[new_start:new_end]) + os.linesep,
+                        )
+                    )
+
+                elif code == "delete":
+                    result.append(
+                        TextEdit(
+                            range=Range(
+                                start=Position(line=old_start, character=0),
+                                end=Position(line=old_end, character=0),
+                            ),
+                            new_text="",
+                        )
+                    )
+
+            if result:
+                return result
+
+        except BaseException as e:
+            self.parent.window.show_message(str(e), MessageType.Error)
+        return None
+
+    async def format_internal(
+        self, document: TextDocument, options: FormattingOptions, **further_options: Any
+    ) -> Optional[List[TextEdit]]:
 
         from robot.parsing.model.blocks import File
         from robot.tidypkg import (
@@ -68,4 +145,8 @@ async def format(
     async def format_range(
         self, sender: Any, document: TextDocument, range: Range, options: FormattingOptions, **further_options: Any
     ) -> Optional[List[TextEdit]]:
+        # TODO implement range formatting
+        # config = await self.get_config(document)
+        # if config and config.enabled and robotidy_installed():
+        #     return await self.format_robot_tidy(document, options, range=range, **further_options)
         return None

robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -51,52 +51,54 @@ async def collect_diagnostics(self, sender: Any, document: TextDocument) -> Diag
         from robocop.run import Robocop
 
         result: List[Diagnostic] = []
-
-        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
-        if workspace_folder is not None:
-            extension_config = await self.get_config(document)
-
-            if extension_config is not None and extension_config.enabled:
-
-                with io.StringIO("") as output:
-                    config = Config(str(workspace_folder.uri.to_path()))
-
-                    config.exec_dir = str(workspace_folder.uri.to_path())
-
-                    config.output = output
-
-                    if extension_config.include:
-                        config.include = set(extension_config.include)
-                    if extension_config.exclude:
-                        config.exclude = set(extension_config.exclude)
-                    if extension_config.configurations:
-                        config.configure = set(extension_config.configurations)
-
-                    analyser = Robocop(from_cli=False, config=config)
-                    analyser.reload_config()
-
-                    model = await self.parent.documents_cache.get_model(document)
-
-                    issues = analyser.run_check(model, str(document.uri.to_path()), document.text)
-
-                    for issue in issues:
-                        d = Diagnostic(
-                            range=Range(
-                                start=Position(line=max(0, issue.line - 1), character=issue.col),
-                                end=Position(line=max(0, issue.end_line - 1), character=issue.end_col),
-                            ),
-                            message=issue.desc,
-                            severity=DiagnosticSeverity.INFORMATION
-                            if issue.severity == RuleSeverity.INFO
-                            else DiagnosticSeverity.WARNING
-                            if issue.severity == RuleSeverity.WARNING
-                            else DiagnosticSeverity.ERROR
-                            if issue.severity == RuleSeverity.ERROR
-                            else DiagnosticSeverity.HINT,
-                            source=self.source_name,
-                            code=f"{issue.severity.value}{issue.rule_id}",
-                        )
-
-                        result.append(d)
+        try:
+            workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+            if workspace_folder is not None:
+                extension_config = await self.get_config(document)
+
+                if extension_config is not None and extension_config.enabled:
+
+                    with io.StringIO("") as output:
+                        config = Config(str(workspace_folder.uri.to_path()))
+
+                        config.exec_dir = str(workspace_folder.uri.to_path())
+
+                        config.output = output
+
+                        if extension_config.include:
+                            config.include = set(extension_config.include)
+                        if extension_config.exclude:
+                            config.exclude = set(extension_config.exclude)
+                        if extension_config.configurations:
+                            config.configure = set(extension_config.configurations)
+
+                        analyser = Robocop(from_cli=False, config=config)
+                        analyser.reload_config()
+
+                        model = await self.parent.documents_cache.get_model(document)
+
+                        issues = analyser.run_check(model, str(document.uri.to_path()), document.text)
+
+                        for issue in issues:
+                            d = Diagnostic(
+                                range=Range(
+                                    start=Position(line=max(0, issue.line - 1), character=issue.col),
+                                    end=Position(line=max(0, issue.end_line - 1), character=issue.end_col),
+                                ),
+                                message=issue.desc,
+                                severity=DiagnosticSeverity.INFORMATION
+                                if issue.severity == RuleSeverity.INFO
+                                else DiagnosticSeverity.WARNING
+                                if issue.severity == RuleSeverity.WARNING
+                                else DiagnosticSeverity.ERROR
+                                if issue.severity == RuleSeverity.ERROR
+                                else DiagnosticSeverity.HINT,
+                                source=self.source_name,
+                                code=f"{issue.severity.value}{issue.rule_id}",
+                            )
+
+                            result.append(d)
+        except BaseException:
+            pass
 
         return DiagnosticsResult(self.collect_diagnostics, result)