feat: first support for RF 7

start implementing #177

Author: d-biehl

packages/analyze/src/robotcode/analyze/cli.py

@@ -3,7 +3,7 @@
 import click
 from robotcode.analyze.config import AnalyzerConfig
 from robotcode.plugin import Application, pass_application
-from robotcode.robot.config.loader import load_config_from_path
+from robotcode.robot.config.loader import load_config_from_path, load_robot_config_from_path
 from robotcode.robot.config.utils import get_config_files
 
 from .__version__ import __version__
@@ -32,12 +32,18 @@ def analyze(
     config_files, root_folder, _ = get_config_files(paths, app.config.config_files, verbose_callback=app.verbose)
 
     try:
-        robot_profile = load_config_from_path(
+        analizer_config = load_config_from_path(
             AnalyzerConfig, *config_files, tool_name="robotcode-analyze", robot_toml_tool_name="robotcode-analyze"
         ).evaluated()
+
+        robot_config = (
+            load_robot_config_from_path(*config_files).combine_profiles(*(app.config.profiles or [])).evaluated()
+        )
+
     except (TypeError, ValueError) as e:
         raise click.ClickException(str(e)) from e
 
-    app.print_data(robot_profile)
+    app.print_data(analizer_config)
+    app.print_data(robot_config)
 
     return 0

packages/core/src/robotcode/core/logging.py

@@ -79,7 +79,7 @@ class _HasLoggerEntries:
     __logging_entries__: List[_LoggerEntry]
 
 
-_FUNC_TYPE = Union[Callable[[], logging.Logger], Callable[[], None], staticmethod, None]
+_FUNC_TYPE = Union[Callable[[], logging.Logger], Callable[[], None], None]
 
 _F = TypeVar("_F", bound=Callable[..., Any])
 

packages/debugger/src/robotcode/debugger/debugger.py

@@ -219,15 +219,31 @@ class PathMapping(NamedTuple):
     remote_root: Optional[str]
 
 
-class DebugLogger:
-    def __init__(self) -> None:
-        self.steps: List[Any] = []
+if get_robot_version() < (7, 0):
+
+    class DebugLogger:
+        def __init__(self) -> None:
+            self.steps: List[Any] = []
+
+        def start_keyword(self, kw: Any) -> None:
+            self.steps.append(kw)
+
+        def end_keyword(self, kw: Any) -> None:
+            self.steps.pop()
+
+else:
+    from robot import result, running
+    from robot.output.loggerapi import LoggerApi
+
+    class DebugLogger(LoggerApi):  # type: ignore[no-redef]
+        def __init__(self) -> None:
+            self.steps: List[Any] = []
 
-    def start_keyword(self, kw: Any) -> None:
-        self.steps.append(kw)
+        def start_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
+            self.steps.append(data)
 
-    def end_keyword(self, kw: Any) -> None:
-        self.steps.pop()
+        def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
+            self.steps.pop()
 
 
 class Debugger:

packages/language_server/src/robotcode/language_server/common/text_document.py

@@ -286,7 +286,7 @@ def remove_data(self, key: Any) -> None:
         except KeyError:
             pass
 
-    def get_data(self, key: Any, default: Optional[_T] = None) -> _T:
+    def get_data(self, key: Any, default: Optional[Any] = None) -> Any:
         return self._data.get(key, default)
 
     def _clear(self) -> None:

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -914,16 +914,29 @@ async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
             self.current_testcase_or_keyword_name = None
 
     def _format_template(self, template: str, arguments: Tuple[str, ...]) -> Tuple[str, Tuple[str, ...]]:
-        from robot.variables import VariableIterator
-
-        variables = VariableIterator(template, identifiers="$")
+        if get_robot_version() < (7, 0):
+            from robot.variables import VariableIterator
+
+            variables = VariableIterator(template, identifiers="$")
+            count = len(variables)
+            if count == 0 or count != len(arguments):
+                return template, arguments
+            temp = []
+            for (before, _, after), arg in zip(variables, arguments):
+                temp.extend([before, arg])
+            temp.append(after)
+            return "".join(temp), ()
+
+        from robot.variables import VariableMatches
+
+        variables = VariableMatches(template, identifiers="$")
         count = len(variables)
         if count == 0 or count != len(arguments):
             return template, arguments
         temp = []
-        for (before, _, after), arg in zip(variables, arguments):
-            temp.extend([before, arg])
-        temp.append(after)
+        for var, arg in zip(variables, arguments):
+            temp.extend([var.before, arg])
+        temp.append(var.after)
         return "".join(temp), ()
 
     async def visit_TemplateArguments(self, node: ast.AST) -> None:  # noqa: N802
@@ -981,22 +994,23 @@ async def visit_ForceTags(self, node: ast.AST) -> None:  # noqa: N802
                     message="`Force Tags` is deprecated in favour of new `Test Tags` setting.",
                     severity=DiagnosticSeverity.INFORMATION,
                     tags=[DiagnosticTag.DEPRECATED],
-                    code=Error.DEPRECATED_HYPHEN_TAG,
+                    code=Error.DEPRECATED_FORCE_TAG,
                 )
 
-    async def visit_DefaultTags(self, node: ast.AST) -> None:  # noqa: N802
+    async def visit_TestTags(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import ForceTags
+        from robot.parsing.model.statements import TestTags
 
         if get_robot_version() >= (6, 0):
-            tag = cast(ForceTags, node).get_token(RobotToken.DEFAULT_TAGS)
-            self.append_diagnostics(
-                range=range_from_node_or_token(node, tag),
-                message="`Force Tags` is deprecated in favour of new `Test Tags` setting.",
-                severity=DiagnosticSeverity.INFORMATION,
-                tags=[DiagnosticTag.DEPRECATED],
-                code=Error.DEPRECATED_HYPHEN_TAG,
-            )
+            tag = cast(TestTags, node).get_token(RobotToken.FORCE_TAGS)
+            if tag is not None and tag.value.upper() == "FORCE TAGS":
+                self.append_diagnostics(
+                    range=range_from_node_or_token(node, tag),
+                    message="`Force Tags` is deprecated in favour of new `Test Tags` setting.",
+                    severity=DiagnosticSeverity.INFORMATION,
+                    tags=[DiagnosticTag.DEPRECATED],
+                    code=Error.DEPRECATED_FORCE_TAG,
+                )
 
     async def visit_Tags(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/errors.py

@@ -27,5 +27,6 @@ class Error:
     TESTCASE_NAME_EMPTY = "TestCaseNameEmpty"
     KEYWORD_CONTAINS_NORMAL_AND_EMBBEDED_ARGUMENTS = "KeywordContainsNormalAndEmbbededArguments"
     DEPRECATED_HYPHEN_TAG = "DeprecatedHyphenTag"
+    DEPRECATED_FORCE_TAG = "DeprecatedForceTag"
     IMPORT_REQUIRES_VALUE = "ImportRequiresValue"
     KEYWORD_ERROR = "KeywordError"

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -581,7 +581,7 @@ async def get_command_line_variables(self) -> List[VariableDefinition]:
                     name, args = split_args_from_name_or_path(str(variable_file))
                     try:
                         lib_doc = await self.get_libdoc_for_variables_import(
-                            name,
+                            name.replace("\\", "\\\\"),
                             tuple(args),
                             str(self.folder.to_path()),
                             self,