robotcode-language-server 1.2.0__tar.gz → 1.3.0__tar.gz

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/PKG-INFO

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

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/pyproject.toml

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

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

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

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/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)
 
 
@@ -49,7 +52,7 @@ class RoboTidyConfig(ConfigBase):
 class DocumentationServerConfig(ConfigBase):
     start_port: int = 3100
     end_port: int = 3199
-    start_on_demand: bool = True
+    start_on_demand: bool = False
 
 
 @config_section("robotcode.inlayHints")

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/document_symbols.py

@@ -6,7 +6,6 @@ from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.blocks import Keyword, Section, TestCase
 from robot.parsing.model.statements import Statement
-from robot.variables import search_variable
 
 from robotcode.core.language import language_id
 from robotcode.core.lsp.types import (
@@ -21,6 +20,7 @@ from robotcode.robot.utils.ast import (
     range_from_token,
     tokenize_variables,
 )
+from robotcode.robot.utils.variables import search_variable
 from robotcode.robot.utils.visitor import Visitor
 
 from .protocol_part import RobotLanguageServerProtocolPart

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/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.is_robocop_notification_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,33 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = self.get_config(document)
+        if self.robocop_installed and self.robocop_version >= (6, 0):
+            if not self.is_robocop_notification_shown and self.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
 
-        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 +99,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 +135,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 +156,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 +190,52 @@ 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)
+        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+
+        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 = 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 +283,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.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/hover.py

@@ -163,7 +163,7 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                     else:
                         value = ""
 
-                    text = f"### {variable.type.value.title()} `{variable.name}`\n\n"
+                    text = f"### {variable.type.value.title()} `{variable.convertable_name}`\n\n"
 
                     if value:
                         text += "```python\n"

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/keywords_treeview.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from robotcode.core.lsp.types import TextDocumentIdentifier
+from robotcode.core.uri import Uri
 from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
@@ -16,6 +17,26 @@ if TYPE_CHECKING:
 @dataclass(repr=False)
 class GetDocumentImportsParams(CamelSnakeMixin):
     text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class GetDocumentKeywordsParams(CamelSnakeMixin):
+    text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class GetLibraryDocumentationParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    library_name: str
+
+
+@dataclass(repr=False)
+class GetKeywordDocumentationParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    library_name: str
+    keyword_name: str
 
 
 @dataclass(repr=False)
@@ -26,6 +47,14 @@ class Keyword(CamelSnakeMixin):
     documentation: Optional[str] = None
 
 
+@dataclass(repr=False)
+class LibraryDocumentation(CamelSnakeMixin):
+    name: str
+    documentation: Optional[str] = None
+    keywords: Optional[List[Keyword]] = None
+    initializers: Optional[List[Keyword]] = None
+
+
 @dataclass(repr=False)
 class DocumentImport(CamelSnakeMixin):
     name: str
@@ -54,6 +83,7 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
     def _get_document_imports(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[DocumentImport]]:
@@ -72,16 +102,18 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
                     alias=v.alias,
                     id=str(hash(v)),
                     type="library",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
                         Keyword(
                             l.name,
                             str(hash(l)),
                             l.parameter_signature(),
-                            l.to_markdown(add_signature=False),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
                         )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
         for _k, v in namespace.get_resources().items():
@@ -91,21 +123,29 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
                     alias=None,
                     id=str(hash(v)),
                     type="resource",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
-                        Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+                        Keyword(
+                            l.name,
+                            str(hash(l)),
+                            l.parameter_signature(),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
+                        )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
 
         return result
 
-    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentImportsParams, threaded=True)
+    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentKeywordsParams, threaded=True)
     @_logger.call
     def _get_document_keywords(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[Keyword]]:
@@ -116,7 +156,12 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
         namespace = self.parent.documents_cache.get_namespace(document)
 
         return [
-            Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+            Keyword(
+                l.name,
+                str(hash(l)),
+                l.parameter_signature(),
+                l.to_markdown(add_signature=False) if not no_documentation else None,
+            )
             for l in namespace.get_library_doc().keywords.values()
         ]
 
@@ -165,3 +210,72 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
             )
 
         return None
+
+    @rpc_method(
+        name="robot/keywordsview/getLibraryDocumentation", param_type=GetLibraryDocumentationParams, threaded=True
+    )
+    @_logger.call
+    def _get_library_documentation(
+        self,
+        workspace_folder_uri: str,
+        library_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[LibraryDocumentation]:
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(Uri(workspace_folder_uri))
+
+        libdoc = imports_manager.get_libdoc_for_library_import(library_name, (), ".")
+        if libdoc.errors:
+            raise ValueError(f"Errors while loading library documentation: {libdoc.errors}")
+
+        return LibraryDocumentation(
+            name=libdoc.name,
+            documentation=libdoc.to_markdown(),
+            keywords=[
+                Keyword(
+                    l.name,
+                    str(hash(l)),
+                    l.parameter_signature(),
+                    l.to_markdown(),
+                )
+                for l in libdoc.keywords.values()
+            ],
+            initializers=[
+                Keyword(
+                    s.name,
+                    str(hash(s)),
+                    s.parameter_signature(),
+                    s.to_markdown(),
+                )
+                for s in libdoc.inits.values()
+            ],
+        )
+
+    @rpc_method(
+        name="robot/keywordsview/getKeywordDocumentation", param_type=GetKeywordDocumentationParams, threaded=True
+    )
+    @_logger.call
+    def _get_keyword_documentation(
+        self,
+        workspace_folder_uri: str,
+        library_name: str,
+        keyword_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[Keyword]:
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(Uri(workspace_folder_uri))
+
+        libdoc = imports_manager.get_libdoc_for_library_import(library_name, (), ".")
+        if libdoc.errors:
+            raise ValueError(f"Errors while loading library documentation: {libdoc.errors}")
+
+        kw = libdoc.keywords.get(keyword_name, None)
+        if kw is None:
+            raise ValueError(f"Keyword '{keyword_name}' not found in library '{library_name}'.")
+
+        return Keyword(
+            name=kw.name,
+            id=str(hash(kw)),
+            signature=kw.parameter_signature(),
+            documentation=kw.to_markdown(),
+        )

{robotcode_language_server-1.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -1,3 +1,4 @@
+import sys
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -7,9 +8,9 @@ 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 ...__version__ import __version__ as robotcode_version
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_diagnostics import robocop_installed
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -20,9 +21,12 @@ 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
 
 
-class ProjectInfoPart(RobotLanguageServerProtocolPart):
+class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -30,25 +34,24 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart):
 
     @rpc_method(name="robot/projectInfo", threaded=True)
     @_logger.call
-    def _get_document_imports(
+    def _robot_project_info(
         self,
         *args: Any,
         **kwargs: Any,
     ) -> ProjectInfo:
         robocop_version_string = None
-        if robocop_installed():
-            from robocop.version import __version__
-
-            robocop_version_string = __version__
+        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(),
             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.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -1,5 +1,6 @@
 import io
 from typing import TYPE_CHECKING, Any, List, Optional
+from weakref import WeakKeyDictionary
 
 from robotcode.core.language import language_id
 from robotcode.core.lsp.types import (
@@ -17,28 +18,24 @@ 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
-
+    from robocop.linter.runner import RobocopLinter
 
-def robocop_installed() -> bool:
-    try:
-        __import__("robocop")
-    except ImportError:
-        return False
-    return True
+    from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
+class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
         super().__init__(parent)
 
         self.source_name = "robocop"
+        self._robocop_linters: WeakKeyDictionary[WorkspaceFolder, "RobocopLinter"] = WeakKeyDictionary()
 
-        if robocop_installed():
+        if self.robocop_installed:
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:
@@ -52,18 +49,26 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
     @_logger.call
     def collect_diagnostics(
         self, sender: Any, document: TextDocument, diagnostics_type: DiagnosticsCollectType
-    ) -> DiagnosticsResult:
-        workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
-        if workspace_folder is not None:
-            extension_config = self.get_config(document)
-
-            if extension_config is not None and extension_config.enabled:
-                return DiagnosticsResult(
-                    self.collect_diagnostics,
-                    self.collect(document, workspace_folder, extension_config),
-                )
+    ) -> Optional[DiagnosticsResult]:
+        if self.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):
+                        # 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_old(document, workspace_folder, config),
+                    )
 
-        return DiagnosticsResult(self.collect_diagnostics, [])
+        return None
 
     @_logger.call
     def collect(
@@ -71,6 +76,69 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
         document: TextDocument,
         workspace_folder: WorkspaceFolder,
         extension_config: RoboCopConfig,
+    ) -> List[Diagnostic]:
+        from robocop.config import ConfigManager
+        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,
+            )
+            linter = RobocopLinter(config_manager)
+            self._robocop_linters[workspace_folder] = linter
+
+        source = document.uri.to_path()
+
+        config = linter.config_manager.get_config_for_source_file(source)
+        model = self.parent.documents_cache.get_model(document, False)
+        diagnostics = linter.run_check(model, source, config)
+
+        return [
+            Diagnostic(
+                range=Range(
+                    start=Position(
+                        line=diagnostic.range.start.line - 1,
+                        character=diagnostic.range.start.character - 1,
+                    ),
+                    end=Position(
+                        line=max(0, diagnostic.range.end.line - 1),
+                        character=max(0, diagnostic.range.end.character - 1),
+                    ),
+                ),
+                message=diagnostic.message,
+                severity=(
+                    DiagnosticSeverity.INFORMATION
+                    if diagnostic.severity == RuleSeverity.INFO
+                    else (
+                        DiagnosticSeverity.WARNING
+                        if diagnostic.severity == RuleSeverity.WARNING
+                        else (
+                            DiagnosticSeverity.ERROR
+                            if diagnostic.severity == RuleSeverity.ERROR
+                            else DiagnosticSeverity.HINT
+                        )
+                    )
+                ),
+                source=self.source_name,
+                code=f"{diagnostic.rule.rule_id}-{diagnostic.rule.name}",
+                code_description=self.get_code_description(self.robocop_version, diagnostic),
+            )
+            for diagnostic in diagnostics
+        ]
+
+    @_logger.call
+    def collect_old(
+        self,
+        document: TextDocument,
+        workspace_folder: WorkspaceFolder,
+        extension_config: RoboCopConfig,
     ) -> List[Diagnostic]:
         from robocop import __version__
         from robocop.config import Config
@@ -181,7 +249,9 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
         if version < (3, 0):
             return None
 
-        base = f"https://robocop.readthedocs.io/en/{version.major}.{version.minor}.{version.patch}"
+        version_letter = "v" if version.major >= 6 else ""
+
+        base = f"https://robocop.readthedocs.io/en/{version_letter}{version.major}.{version.minor}.{version.patch}"
 
         if version < (4, 0):
             return CodeDescription(href=f"{base}/rules.html#{issue.name}".lower())
@@ -194,4 +264,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
                 href=f"{base}/rules_list.html#{issue.name}-{issue.severity.value}{issue.rule_id}".lower()
             )
 
-        return CodeDescription(href=f"{base}/rules_list.html#{issue.name}".lower())
+        if version < (6, 0):
+            return CodeDescription(href=f"{base}/rules_list.html#{issue.name}".lower())
+
+        return CodeDescription(href=f"{base}/rules/rules_list.html#{issue.rule.rule_id}-{issue.rule.name}".lower())

robotcode_language_server-1.3.0/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.2.0 → robotcode_language_server-1.3.0}/src/robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -70,7 +70,7 @@ from robotcode.robot.utils.ast import (
     iter_over_keyword_names_and_owners,
     token_in_range,
 )
-from robotcode.robot.utils.variables import is_variable, split_from_equals
+from robotcode.robot.utils.variables import split_from_equals
 
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -116,6 +116,8 @@ class RobotSemTokenTypes(Enum):
     FOR_SEPARATOR = "forSeparator"
     VARIABLE_BEGIN = "variableBegin"
     VARIABLE_END = "variableEnd"
+    EXPRESSION_BEGIN = "expressionBegin"
+    EXPRESSION_END = "expressionEnd"
     VARIABLE_EXPRESSION = "variableExpression"
     ESCAPE = "escape"
     NAMESPACE = "namespace"
@@ -362,46 +364,8 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                 sem_mod = {SemanticTokenModifiers.DOCUMENTATION}
 
             if token.type in [Token.VARIABLE, Token.ASSIGN]:
-                if is_variable(token.value, "$@&%"):
-                    if col_offset is None:
-                        col_offset = token.col_offset
-                    if length is None:
-                        length = token.end_col_offset - token.col_offset
-
-                    last_index = token.value.rfind("}")
-
-                    is_expr = token.value[1:2] == "{" and token.value[last_index - 1 : last_index] == "}"
-
-                    if last_index >= 0:
-                        yield SemTokenInfo(
-                            token.lineno,
-                            col_offset,
-                            3 if is_expr else 2,
-                            RobotSemTokenTypes.VARIABLE_BEGIN,
-                            sem_mod,
-                        )
-
-                        yield SemTokenInfo(
-                            token.lineno,
-                            col_offset + ((last_index - 1) if is_expr else last_index),
-                            2 if is_expr else 1,
-                            RobotSemTokenTypes.VARIABLE_END,
-                            sem_mod,
-                        )
-
-                        if length - last_index - 1 > 0:
-                            yield SemTokenInfo.from_token(
-                                token,
-                                sem_type,
-                                sem_mod,
-                                col_offset + last_index + 1,
-                                length - last_index - 1,
-                            )
-                    else:
-                        yield SemTokenInfo.from_token(token, sem_type, sem_mod)
-
-                else:
-                    yield SemTokenInfo.from_token(token, sem_type, sem_mod)
+                # TODO: maybe we can distinguish between local and global variables, by default all variables are global
+                pass
 
             elif token.type in [Token.KEYWORD, ROBOT_KEYWORD_INNER] or (
                 token.type == Token.NAME and cached_isinstance(node, Fixture, Template, TestTemplate)
@@ -507,7 +471,9 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                         sem_mod.add(RobotSemTokenModifiers.BUILTIN)
 
                 if kw_doc is not None and kw_doc.is_embedded and kw_doc.matcher.embedded_arguments:
-                    if get_robot_version() >= (6, 0):
+                    if get_robot_version() >= (7, 3):
+                        m = kw_doc.matcher.embedded_arguments.name.fullmatch(kw)
+                    elif get_robot_version() >= (6, 0):
                         m = kw_doc.matcher.embedded_arguments.match(kw)
                     else:
                         m = kw_doc.matcher.embedded_arguments.name.match(kw)

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

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