Implement API changes for Robotidy >= 2.2, fixes #55

Author: d-biehl

robotcode/language_server/robotframework/parts/formatting.py

@@ -23,6 +23,7 @@
     from ..protocol import RobotLanguageServerProtocol
 
 from ..configuration import RoboTidyConfig
+from ..utils.version import create_version_from_str
 from .model_helper import ModelHelperMixin
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -43,8 +44,8 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
 
         parent.formatting.format.add(self.format)
 
-        # TODO implement range formatting
-        # parent.formatting.format_range.add(self.format_range)
+        if robotidy_installed():
+            parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
         self.use_pipes = False
@@ -82,19 +83,37 @@ async def format(
     RE_LINEBREAKS = re.compile(r"\r\n|\r|\n")
 
     async def format_robot_tidy(
-        self, document: TextDocument, options: FormattingOptions, **further_options: Any
+        self, document: TextDocument, options: FormattingOptions, range: Optional[Range] = None, **further_options: Any
     ) -> Optional[List[TextEdit]]:
 
         from difflib import SequenceMatcher
 
         from robotidy.api import RobotidyAPI
+        from robotidy.version import __version__
 
         try:
             model = await self.parent.documents_cache.get_model(document, False)
+            if model is None:
+                return None
 
             robot_tidy = RobotidyAPI(document.uri.to_path(), None)
 
-            changed, _, new = robot_tidy.transform(model)
+            if range is not None:
+                robot_tidy.formatting_config.start_line = range.start.line
+                robot_tidy.formatting_config.end_line = range.end.line + 1
+
+            if create_version_from_str(__version__) >= (2, 2):
+                from robotidy.disablers import RegisterDisablers
+
+                disabler_finder = RegisterDisablers(
+                    robot_tidy.formatting_config.start_line, robot_tidy.formatting_config.end_line
+                )
+                disabler_finder.visit(model)
+                if disabler_finder.file_disabled:
+                    return None
+                changed, _, new = robot_tidy.transform(model, disabler_finder.disablers)
+            else:
+                changed, _, new = robot_tidy.transform(model)
 
             if not changed:
                 return None
@@ -173,8 +192,9 @@ async def format_internal(
     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)
+
+        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/utils/version.py

@@ -1,15 +1,15 @@
 import re
 from typing import NamedTuple, Optional
 
-__all__ = ["InvalidRobotVersionError", "get_robot_version"]
+__all__ = ["InvalidVersionError", "get_robot_version"]
 
 
-class InvalidRobotVersionError(Exception):
+class InvalidVersionError(Exception):
     def __init__(self) -> None:
         super().__init__("Invalid robot version string.")
 
 
-class RobotVersion(NamedTuple):
+class Version(NamedTuple):
     major: int
     minor: int
     patch: Optional[int] = None
@@ -18,13 +18,16 @@ class RobotVersion(NamedTuple):
     dev: Optional[int] = None
 
 
-def get_robot_version() -> RobotVersion:
+def get_robot_version() -> Version:
     import robot
 
+    return create_version_from_str(robot.get_version())
+
+
+def create_version_from_str(version_str: str) -> Version:
     def s_to_i(s: Optional[str]) -> Optional[int]:
         return int(s) if s is not None else None
 
-    robot_version = robot.get_version()
     try:
         m = re.match(
             r"(?P<major>\d+)"
@@ -33,11 +36,11 @@ def s_to_i(s: Optional[str]) -> Optional[int]:
             r"((?P<pre_id>a|b|rc)(?P<pre_number>\d+))?"
             r"(\.(dev(?P<dev>\d+)))?"
             r"(?P<rest>.+)?",
-            robot_version,
+            version_str,
         )
 
         if m is not None and m.group("rest") is None:
-            return RobotVersion(
+            return Version(
                 int(m.group("major")),
                 int(m.group("minor")),
                 s_to_i(m.group("patch")),
@@ -48,9 +51,9 @@ def s_to_i(s: Optional[str]) -> Optional[int]:
     except (SystemExit, KeyboardInterrupt):
         raise
     except BaseException as ex:
-        raise InvalidRobotVersionError() from ex
+        raise InvalidVersionError() from ex
 
-    raise InvalidRobotVersionError()
+    raise InvalidVersionError()
 
 
 if __name__ == "__main__":