implement localizations for robot >= 5.1

d-biehl · d-biehl · commit d2cf28c930e4 · 2022-07-18T15:04:25.000+02:00
diff --git a/package.json b/package.json
@@ -312,6 +312,15 @@
             "description": "Specifies the environment variables for robotframework.",
             "scope": "resource"
           },
+          "robotcode.robot.languages": {
+            "type": "array",
+            "default": [],
+            "items": {
+              "type": "string"
+            },
+            "markdownDescription": "Specifies the supported language(s) that can be used to write _robot_ files. Corresponds to the '`--language lang *`' option of __robot__.",
+            "scope": "resource"
+          },
           "robotcode.robot.variables": {
             "type": "object",
             "default": {},
@@ -637,6 +646,14 @@
                 "description": "Defines a template for the python launch configuration.",
                 "default": {}
               },
+              "languages": {
+                "type": "array",
+                "default": [],
+                "items": {
+                  "type": "string"
+                },
+                "markdownDescription": "Specifies the supported language(s) that can be used to write _robot_ files. Corresponds to the '`--language lang *`' option of __robot__."
+              },
               "variables": {
                 "type": "object",
                 "default": {},
diff --git a/robotcode/debugger/launcher/server.py b/robotcode/debugger/launcher/server.py
@@ -145,6 +145,7 @@ async def _launch(
         dryRun: Optional[bool] = None,
         mode: Optional[str] = None,
         variableFiles: Optional[List[str]] = None,
+        languages: Optional[List[str]] = None,
         arguments: Optional[LaunchRequestArguments] = None,
         *_args: Any,
         **_kwargs: Any,
@@ -184,6 +185,10 @@ async def _launch(
 
         run_args += ["--"]
 
+        if languages:
+            for lang in languages:
+                run_args += ["--language", lang]
+
         if mode:
             if mode == "rpa":
                 run_args += ["--rpa"]
diff --git a/robotcode/language_server/robotframework/configuration.py b/robotcode/language_server/robotframework/configuration.py
@@ -35,6 +35,7 @@ class RobotConfig(ConfigBase):
     debug_file: Optional[str] = None
     log_level: Optional[str] = None
     mode: Optional[RpaMode] = None
+    languages: Optional[List[str]] = None
 
     def get_rpa_mode(self) -> Optional[bool]:
         if self.mode == RpaMode.RPA:
diff --git a/robotcode/language_server/robotframework/parts/discovering.py b/robotcode/language_server/robotframework/parts/discovering.py
@@ -125,7 +125,13 @@ async def _get_tests_from_workspace(
             SuiteStructureParser,
             TestSuiteBuilder,
         )
-        from robot.running.builder.testsettings import TestDefaults
+
+        from ..utils.version import get_robot_version
+
+        if get_robot_version() >= (5, 1):
+            from robot.running.builder.settings import Defaults as TestDefaults
+        else:
+            from robot.running.builder.testsettings import TestDefaults
 
         def get_document_text(source: str) -> str:
             if self.parent._loop:
@@ -159,7 +165,15 @@ def _build(
                     defaults = TestDefaults()
                 if model is None:
                     try:
-                        model = get_model(self._get_source(source), data_only=True, curdir=self._get_curdir(source))
+                        if get_robot_version() >= (5, 1):
+                            model = get_model(
+                                self._get_source(source),
+                                data_only=True,
+                                curdir=self._get_curdir(source),
+                                lang=self.lang,
+                            )
+                        else:
+                            model = get_model(self._get_source(source), data_only=True, curdir=self._get_curdir(source))
                     except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
                         raise
                     except BaseException:
@@ -181,6 +195,24 @@ def _get_source(self, source: str) -> Any:
                 with FileReader(source) as reader:
                     return read_rest_data(reader)
 
+        class MySuiteStructureParserWithLang(SuiteStructureParser):
+            def _get_parsers(self, extensions: List[str], lang: Any, process_curdir: bool) -> RobotParser:
+                robot_parser = MyRobotParser(lang, process_curdir)
+                rest_parser = MyRestParser(lang, process_curdir)
+                parsers = {
+                    None: NoInitFileDirectoryParser(),
+                    "robot": robot_parser,
+                    "rst": rest_parser,
+                    "rest": rest_parser,
+                }
+                for ext in extensions:
+                    if ext not in parsers:
+                        parsers[ext] = robot_parser
+                return parsers
+
+            def _validate_execution_mode(self, suite: Any) -> None:
+                super()._validate_execution_mode(suite)
+
         class MySuiteStructureParser(SuiteStructureParser):
             def _get_parsers(self, extensions: List[str], process_curdir: bool) -> RobotParser:
                 robot_parser = MyRobotParser(process_curdir)
@@ -206,7 +238,12 @@ def _validate_test_counts(self, suite: TestSuite, multisource: bool = False) ->
 
             def build(self, *paths: str) -> TestSuite:
                 structure = SuiteStructureBuilder(self.included_extensions, self.included_suites).build(paths)
-                parser = MySuiteStructureParser(self.included_extensions, self.rpa, self.process_curdir)
+                if get_robot_version() >= (5, 1):
+                    parser = MySuiteStructureParserWithLang(
+                        self.included_extensions, self.rpa, self.lang, self.process_curdir
+                    )
+                else:
+                    parser = MySuiteStructureParser(self.included_extensions, self.rpa, self.process_curdir)
                 suite = parser.parse(structure)
                 if not self.included_suites and not self.allow_empty_suite:
                     self._validate_test_counts(suite, multisource=len(paths) > 1)
@@ -259,6 +296,7 @@ def generate(suite: TestSuite) -> TestItem:
             try:
                 config = await self.get_config(workspace_folder)
                 rpa_mode = config.get_rpa_mode() if config is not None else None
+                languages = config.languages if config is not None else None
 
                 if paths is None and config is not None:
                     paths = config.paths
@@ -290,14 +328,15 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
                                 yield str(p)
 
                     valid_paths = [i for i in normalize_paths(paths)]
-                    suite: Optional[TestSuite] = (
-                        MyTestSuiteBuilder(
-                            included_suites=suites if suites else None,
-                            rpa=rpa_mode,
-                        ).build(*valid_paths)
-                        if valid_paths
-                        else None
-                    )
+
+                    if get_robot_version() >= (5, 1):
+                        builder = MyTestSuiteBuilder(
+                            included_suites=suites if suites else None, rpa=rpa_mode, lang=languages
+                        )
+                    else:
+                        builder = MyTestSuiteBuilder(included_suites=suites if suites else None, rpa=rpa_mode)
+
+                    suite: Optional[TestSuite] = builder.build(*valid_paths) if valid_paths else None
                     suite_item = [generate(suite)] if suite else []
 
                     return [
@@ -323,13 +362,13 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
                         )
                     ]
                 else:
-                    return [
-                        generate(
-                            MyTestSuiteBuilder(included_suites=suites if suites else None, rpa=rpa_mode).build(
-                                str(workspace_path)
-                            )
+                    if get_robot_version() >= (5, 1):
+                        builder = MyTestSuiteBuilder(
+                            included_suites=suites if suites else None, rpa=rpa_mode, lang=languages
                         )
-                    ]
+                    else:
+                        builder = MyTestSuiteBuilder(included_suites=suites if suites else None, rpa=rpa_mode)
+                    return [generate(builder.build(str(workspace_path)))]
             except (SystemExit, KeyboardInterrupt):
                 raise
             except BaseException as e:
diff --git a/robotcode/language_server/robotframework/parts/documents_cache.py b/robotcode/language_server/robotframework/parts/documents_cache.py
@@ -28,6 +28,7 @@
 from ..diagnostics.imports_manager import ImportsManager
 from ..diagnostics.namespace import DocumentType, Namespace
 from ..utils.ast_utils import Token
+from ..utils.version import get_robot_version
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -47,6 +48,23 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self._imports_managers: weakref.WeakKeyDictionary[WorkspaceFolder, ImportsManager] = weakref.WeakKeyDictionary()
         self._default_imports_manager: Optional[ImportsManager] = None
 
+    async def get_languages(self, document: TextDocument) -> Optional[List[str]]:
+        if get_robot_version() < (5, 1):
+            return None
+
+        folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if folder is None:
+            return None
+
+        config = await self.parent.workspace.get_configuration(RobotConfig, folder.uri)
+
+        lang = config.languages
+
+        if isinstance(lang, List) and len(lang) == 0:
+            lang = None
+
+        return lang
+
     async def get_document_type(self, document: TextDocument) -> DocumentType:
         return await document.get_cache(self.__get_document_type)
 
@@ -95,21 +113,59 @@ async def get_general_tokens(self, document: TextDocument, data_only: bool = Fal
             return await document.get_cache(self.__get_general_tokens_data_only)
         return await document.get_cache(self.__get_general_tokens)
 
-    async def __get_general_tokens_data_only(self, document: TextDocument) -> List[Token]:
+    def __internal_get_tokens(
+        self, source: Any, data_only: bool = False, tokenize_variables: bool = False, lang: Any = None
+    ) -> Any:
         import robot.api
 
+        if get_robot_version() >= (5, 1):
+            return robot.api.get_tokens(source, data_only=data_only, tokenize_variables=tokenize_variables, lang=lang)
+        else:
+            return robot.api.get_tokens(source, data_only=data_only, tokenize_variables=tokenize_variables)
+
+    def __internal_get_resource_tokens(
+        self,
+        source: Any,
+        data_only: bool = False,
+        tokenize_variables: bool = False,
+        lang: Any = None,
+    ) -> Any:
+        import robot.api
+
+        if get_robot_version() >= (5, 1):
+            return robot.api.get_resource_tokens(
+                source, data_only=data_only, tokenize_variables=tokenize_variables, lang=lang
+            )
+        else:
+            return robot.api.get_resource_tokens(source, data_only=data_only, tokenize_variables=tokenize_variables)
+
+    def __internal_get_init_tokens(
+        self, source: Any, data_only: bool = False, tokenize_variables: bool = False, lang: Any = None
+    ) -> Any:
+        import robot.api
+
+        if get_robot_version() >= (5, 1):
+            return robot.api.get_init_tokens(
+                source, data_only=data_only, tokenize_variables=tokenize_variables, lang=lang
+            )
+        else:
+            return robot.api.get_init_tokens(source, data_only=data_only, tokenize_variables=tokenize_variables)
+
+    async def __get_general_tokens_data_only(self, document: TextDocument) -> List[Token]:
+        lang = await self.get_languages(document)
+
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_tokens(content, True) if check_canceled_sync()]
+                return [e for e in self.__internal_get_tokens(content, True, lang=lang) if check_canceled_sync()]
 
         return await self.__get_tokens_internal(document, get)
 
     async def __get_general_tokens(self, document: TextDocument) -> List[Token]:
-        import robot.api
+        lang = await self.get_languages(document)
 
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_tokens(content) if check_canceled_sync()]
+                return [e for e in self.__internal_get_tokens(content, lang=lang) if check_canceled_sync()]
 
         return await self.__get_tokens_internal(document, get)
 
@@ -128,20 +184,22 @@ async def get_resource_tokens(self, document: TextDocument, data_only: bool = Fa
         return await document.get_cache(self.__get_resource_tokens)
 
     async def __get_resource_tokens_data_only(self, document: TextDocument) -> List[Token]:
-        import robot.api
+        lang = await self.get_languages(document)
 
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_resource_tokens(content, True) if check_canceled_sync()]
+                return [
+                    e for e in self.__internal_get_resource_tokens(content, True, lang=lang) if check_canceled_sync()
+                ]
 
         return await self.__get_tokens_internal(document, get)
 
     async def __get_resource_tokens(self, document: TextDocument) -> List[Token]:
-        import robot.api
+        lang = await self.get_languages(document)
 
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_resource_tokens(content) if check_canceled_sync()]
+                return [e for e in self.__internal_get_resource_tokens(content, lang=lang) if check_canceled_sync()]
 
         return await self.__get_tokens_internal(document, get)
 
@@ -151,20 +209,20 @@ async def get_init_tokens(self, document: TextDocument, data_only: bool = False)
         return await document.get_cache(self.__get_init_tokens)
 
     async def __get_init_tokens_data_only(self, document: TextDocument) -> List[Token]:
-        import robot.api
+        lang = await self.get_languages(document)
 
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_init_tokens(content, True) if check_canceled_sync()]
+                return [e for e in self.__internal_get_init_tokens(content, True, lang=lang) if check_canceled_sync()]
 
         return await self.__get_tokens_internal(document, get)
 
     async def __get_init_tokens(self, document: TextDocument) -> List[Token]:
-        import robot.api
+        lang = await self.get_languages(document)
 
         def get(text: str) -> List[Token]:
             with io.StringIO(text) as content:
-                return [e for e in robot.api.get_init_tokens(content) if check_canceled_sync()]
+                return [e for e in self.__internal_get_init_tokens(content, lang=lang) if check_canceled_sync()]
 
         return await self.__get_tokens_internal(document, get)
 
@@ -184,7 +242,7 @@ def __get_model(self, document: TextDocument, tokens: Iterable[Any], document_ty
         from robot.parsing.lexer import Token
         from robot.parsing.parser.parser import _get_model
 
-        def get_tokens(_source: str, _data_only: bool = False) -> Generator[Token, None, None]:
+        def get_tokens(source: str, data_only: bool = False, lang: Any = None) -> Generator[Token, None, None]:
             for t in tokens:
                 check_canceled_sync()
 
diff --git a/robotcode/language_server/robotframework/utils/version.py b/robotcode/language_server/robotframework/utils/version.py
@@ -18,10 +18,16 @@ class Version(NamedTuple):
     dev: Optional[int] = None
 
 
+_robot_version: Optional[Version] = None
+
+
 def get_robot_version() -> Version:
-    import robot
+    global _robot_version
+    if _robot_version is None:
+        import robot
 
-    return create_version_from_str(robot.get_version())
+        return create_version_from_str(robot.get_version())
+    return _robot_version
 
 
 def create_version_from_str(version_str: str) -> Version:
diff --git a/vscode-client/debugmanager.ts b/vscode-client/debugmanager.ts
@@ -126,6 +126,9 @@ class RobotCodeDebugConfigurationProvider implements vscode.DebugConfigurationPr
 
     debugConfiguration.mode = debugConfiguration?.mode ?? config.get<string | undefined>("robot.mode", undefined);
 
+    debugConfiguration.languages =
+      debugConfiguration?.languages ?? config.get<string | undefined>("robot.languages", undefined);
+
     debugConfiguration.attachPython = debugConfiguration?.attachPython ?? config.get<boolean>("debug.attachPython");
 
     debugConfiguration.outputMessages =
