robotcode-language-server 1.9.0__tar.gz → 2.0.0__tar.gz

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-language-server
-Version: 1.9.0
+Version: 2.0.0
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -15,19 +15,20 @@ Classifier: Framework :: Robot Framework
 Classifier: Framework :: Robot Framework :: Tool
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
-Requires-Dist: robotcode-analyze==1.9.0
-Requires-Dist: robotcode-jsonrpc2==1.9.0
-Requires-Dist: robotcode-robot==1.9.0
-Requires-Dist: robotcode==1.9.0
+Requires-Python: >=3.10
+Requires-Dist: robotcode-analyze==2.0.0
+Requires-Dist: robotcode-jsonrpc2==2.0.0
+Requires-Dist: robotcode-robot==2.0.0
+Requires-Dist: robotcode==2.0.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/pyproject.toml

@@ -6,17 +6,18 @@ build-backend = "hatchling.build"
 name = "robotcode-language-server"
 description = 'RobotCode Language Server for Robot Framework'
 readme = { "file" = "README.md", "content-type" = "text/markdown" }
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = {text = "Apache-2.0"}
 keywords = []
 authors = [{ name = "Daniel Biehl", email = "dbiehl@live.de" }]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.8",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Operating System :: OS Independent",
@@ -27,10 +28,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==1.9.0",
-  "robotcode-robot==1.9.0",
-  "robotcode-analyze==1.9.0",
-  "robotcode==1.9.0",
+  "robotcode-jsonrpc2==2.0.0",
+  "robotcode-robot==2.0.0",
+  "robotcode-analyze==2.0.0",
+  "robotcode==2.0.0",
 ]
 dynamic = ["version"]
 
@@ -53,11 +54,11 @@ dev-mode-dirs = ["src"]
 
 [tool.hatch.build.targets.wheel]
 only-include = ["src/robotcode"]
-sources = ["src"]
+
 
 [tool.hatch.build.targets.sdist]
 only-include = ["src"]
 
 [tool.hatch.envs.build]
 detached = true
-python = "38"
+python = "310"

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

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

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/src/robotcode/language_server/robotframework/configuration.py

@@ -39,14 +39,6 @@ class RoboCopConfig(ConfigBase):
     configurations: List[str] = field(default_factory=list)
 
 
-@config_section("robotcode.robotidy")
-@dataclass
-class RoboTidyConfig(ConfigBase):
-    enabled: bool = True
-    ignore_git_dir: bool = False
-    config: Optional[str] = None
-
-
 @config_section("robotcode.documentationServer")
 @dataclass
 class DocumentationServerConfig(ConfigBase):

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/src/robotcode/language_server/robotframework/parts/completion.py

@@ -1739,7 +1739,7 @@ class CompletionCollector(ModelHelper):
                         )
                     ),
                     detail=e.kind.value,
-                    sort_text=f"030_{e}",
+                    sort_text=f"030_{e.label}",
                     insert_text_format=InsertTextFormat.PLAIN_TEXT,
                     text_edit=TextEdit(range=r, new_text=e.label) if r is not None else None,
                     data=CompletionItemData(
@@ -1936,7 +1936,7 @@ class CompletionCollector(ModelHelper):
                     )
                 ),
                 detail=e.kind.value,
-                sort_text=f"030_{e}",
+                sort_text=f"030_{e.label}",
                 insert_text_format=InsertTextFormat.PLAIN_TEXT,
                 text_edit=TextEdit(range=r, new_text=e.label) if r is not None else None,
                 data=CompletionItemData(
@@ -2060,7 +2060,7 @@ class CompletionCollector(ModelHelper):
                         )
                     ),
                     detail=e.kind.value,
-                    sort_text=f"030_{e}",
+                    sort_text=f"030_{e.label}",
                     insert_text_format=InsertTextFormat.PLAIN_TEXT,
                     text_edit=TextEdit(range=r, new_text=e.label) if r is not None else None,
                     data=CompletionItemData(

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/src/robotcode/language_server/robotframework/parts/folding_range.py

@@ -83,6 +83,10 @@ class _Visitor(Visitor):
         self.__append(node, kind="comment")
         self.generic_visit(node)
 
+    def visit_Documentation(self, node: ast.AST) -> None:  # noqa: N802
+        self.__append(node, kind="documentation")
+        self.generic_visit(node)
+
     def visit_TestCase(self, node: TestCase) -> None:  # noqa: N802
         if node.name:
             self.__append(node, kind="testcase")

robotcode_language_server-2.0.0/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -0,0 +1,161 @@
+import io
+import os
+from typing import TYPE_CHECKING, Any, List, Optional, cast
+
+from robotcode.core.language import language_id
+from robotcode.core.lsp.types import (
+    FormattingOptions,
+    MessageType,
+    Position,
+    Range,
+    TextEdit,
+)
+from robotcode.core.text_document import TextDocument
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.robot.utils import get_robot_version
+
+from ..configuration import RoboCopConfig
+from .protocol_part import RobotLanguageServerProtocolPart
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+
+class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+
+        parent.formatting.format.add(self.format)
+
+        if 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
+        self.use_pipes = False
+        self.line_separator = os.linesep
+        self.short_test_name_length = 18
+        self.setting_and_variable_name_length = 14
+        self.is_robocop_notification_shown = False
+
+    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(
+        self,
+        sender: Any,
+        document: TextDocument,
+        options: FormattingOptions,
+        **further_options: Any,
+    ) -> Optional[List[TextEdit]]:
+        if self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0):
+            return self.format_robocop(document, options, **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-robocop'.",
+            MessageType.ERROR,
+        )
+
+        return None
+
+    def format_robocop(
+        self,
+        document: TextDocument,
+        options: FormattingOptions,
+        range: Optional[Range] = None,
+        **further_options: Any,
+    ) -> Optional[List[TextEdit]]:
+        from robocop.formatter.runner import RobocopFormatter
+
+        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if workspace_folder is None:
+            return None
+
+        config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
+
+        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,
+        options: FormattingOptions,
+        **further_options: Any,
+    ) -> Optional[List[TextEdit]]:
+        from robot.parsing.model.blocks import File
+        from robot.tidypkg import (  # pyright: ignore [reportMissingImports]
+            Aligner,
+            Cleaner,
+            NewlineNormalizer,
+            SeparatorNormalizer,
+        )
+
+        model = cast(File, self.parent.documents_cache.get_model(document, False))
+
+        Cleaner().visit(model)
+        NewlineNormalizer(self.line_separator, self.short_test_name_length).visit(model)
+        SeparatorNormalizer(self.use_pipes, self.space_count).visit(model)
+        Aligner(
+            self.short_test_name_length,
+            self.setting_and_variable_name_length,
+            self.use_pipes,
+        ).visit(model)
+
+        with io.StringIO() as s:
+            model.save(s)
+
+            return [
+                TextEdit(
+                    range=Range(
+                        start=Position(line=0, character=0),
+                        end=Position(line=len(document.get_lines()), character=0),
+                    ),
+                    new_text=s.getvalue(),
+                )
+            ]
+
+    @language_id("robotframework")
+    def format_range(
+        self,
+        sender: Any,
+        document: TextDocument,
+        range: Range,
+        options: FormattingOptions,
+        **further_options: Any,
+    ) -> Optional[List[TextEdit]]:
+        if self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0):
+            return self.format_robocop(document, options, range=range, **further_options)
+
+        return None

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -19,7 +19,6 @@ if TYPE_CHECKING:
 class ProjectInfo(CamelSnakeMixin):
     robot_version_string: str
     robocop_version_string: Optional[str]
-    tidy_version_string: Optional[str] = None
     python_version_string: Optional[str] = None
     python_executable: Optional[str] = None
     robot_code_version_string: Optional[str] = None
@@ -42,14 +41,9 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart):
         if self.parent.robocop_helper.robocop_installed:
             robocop_version_string = self.parent.robocop_helper.robocop_version_str
 
-        tidy_version_string = None
-        if self.parent.robocop_helper.robotidy_installed:
-            tidy_version_string = self.parent.robocop_helper.robotidy_version_str
-
         return ProjectInfo(
             robot_version_string=get_version(),
             robocop_version_string=robocop_version_string,
-            tidy_version_string=tidy_version_string,
             python_version_string=sys.version,
             python_executable=sys.executable,
             robot_code_version_string=robotcode_version,

{robotcode_language_server-1.9.0 → robotcode_language_server-2.0.0}/src/robotcode/language_server/robotframework/parts/robocop_helper.py

@@ -29,26 +29,6 @@ class RoboCopHelper(RobotLanguageServerProtocolPart):
         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:

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

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

robotcode_language_server-1.9.0/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -1,287 +0,0 @@
-import io
-import os
-from concurrent.futures import CancelledError
-from typing import TYPE_CHECKING, Any, List, Optional, cast
-
-from robotcode.core.language import language_id
-from robotcode.core.lsp.types import (
-    FormattingOptions,
-    MessageType,
-    Position,
-    Range,
-    TextEdit,
-)
-from robotcode.core.text_document import TextDocument
-from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.robot.utils import get_robot_version
-
-from ..configuration import RoboCopConfig, RoboTidyConfig
-from .protocol_part import RobotLanguageServerProtocolPart
-
-if TYPE_CHECKING:
-    from ..protocol import RobotLanguageServerProtocol
-
-
-class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart):
-    _logger = LoggingDescriptor()
-
-    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
-        super().__init__(parent)
-
-        parent.formatting.format.add(self.format)
-
-        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
-        self.use_pipes = False
-        self.line_separator = os.linesep
-        self.short_test_name_length = 18
-        self.setting_and_variable_name_length = 14
-        self.is_robocop_notification_shown = False
-
-    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(
-        self,
-        sender: Any,
-        document: TextDocument,
-        options: FormattingOptions,
-        **further_options: Any,
-    ) -> Optional[List[TextEdit]]:
-        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"
-                    "Robocop fully supports all formatting tasks and provides a more comprehensive solution.\n\n"
-                    "Note: The use of `robotframework-tidy` is deprecated and should be avoided in favor of Robocop.",
-                    MessageType.INFO,
-                )
-                self.is_robocop_notification_shown = True
-
-            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.parent.robocop_helper.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-robocop'.",
-            MessageType.ERROR,
-        )
-
-        return None
-
-    def format_robot_tidy(
-        self,
-        document: TextDocument,
-        options: FormattingOptions,
-        range: Optional[Range] = None,
-        config: Optional[RoboTidyConfig] = None,
-        **further_options: Any,
-    ) -> Optional[List[TextEdit]]:
-        try:
-            if config is None:
-                config = self.get_tidy_config(document)
-
-            model = self.parent.documents_cache.get_model(document, False)
-
-            if self.parent.robocop_helper.robotidy_version >= (3, 0):
-                from robotidy.api import get_robotidy
-                from robotidy.disablers import RegisterDisablers
-
-                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.parent.robocop_helper.robotidy_version >= (4, 1):
-                    robot_tidy = get_robotidy(
-                        document.uri.to_path(),
-                        None,
-                        ignore_git_dir=config.ignore_git_dir,
-                    )
-                else:
-                    robot_tidy = get_robotidy(document.uri.to_path(), None)
-
-                if range is not None:
-                    robot_tidy.config.formatting.start_line = range.start.line + 1
-                    robot_tidy.config.formatting.end_line = range.end.line + 1
-
-                disabler_finder = RegisterDisablers(
-                    robot_tidy.config.formatting.start_line,
-                    robot_tidy.config.formatting.end_line,
-                )
-                disabler_finder.visit(model)
-
-                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.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)
-
-            else:
-                from robotidy.api import RobotidyAPI
-
-                robot_tidy = RobotidyAPI(document.uri.to_path(), None)
-
-                if range is not None:
-                    robot_tidy.formatting_config.start_line = range.start.line + 1
-                    robot_tidy.formatting_config.end_line = range.end.line + 1
-
-                if self.parent.robocop_helper.robotidy_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
-                    _, _, new = robot_tidy.transform(model, disabler_finder.disablers)
-                else:
-                    _, _, new = robot_tidy.transform(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,
-                )
-            ]
-
-        except (SystemExit, KeyboardInterrupt, CancelledError):
-            raise
-        except BaseException as e:
-            self._logger.exception(e)
-            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.formatter.runner import RobocopFormatter
-
-        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
-        if workspace_folder is None:
-            return None
-
-        config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
-
-        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,
-        options: FormattingOptions,
-        **further_options: Any,
-    ) -> Optional[List[TextEdit]]:
-        from robot.parsing.model.blocks import File
-        from robot.tidypkg import (  # pyright: ignore [reportMissingImports]
-            Aligner,
-            Cleaner,
-            NewlineNormalizer,
-            SeparatorNormalizer,
-        )
-
-        model = cast(File, self.parent.documents_cache.get_model(document, False))
-
-        Cleaner().visit(model)
-        NewlineNormalizer(self.line_separator, self.short_test_name_length).visit(model)
-        SeparatorNormalizer(self.use_pipes, self.space_count).visit(model)
-        Aligner(
-            self.short_test_name_length,
-            self.setting_and_variable_name_length,
-            self.use_pipes,
-        ).visit(model)
-
-        with io.StringIO() as s:
-            model.save(s)
-
-            return [
-                TextEdit(
-                    range=Range(
-                        start=Position(line=0, character=0),
-                        end=Position(line=len(document.get_lines()), character=0),
-                    ),
-                    new_text=s.getvalue(),
-                )
-            ]
-
-    @language_id("robotframework")
-    def format_range(
-        self,
-        sender: Any,
-        document: TextDocument,
-        range: Range,
-        options: FormattingOptions,
-        **further_options: Any,
-    ) -> Optional[List[TextEdit]]:
-        config = self.get_tidy_config(document)
-        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