implement setting for filtering default language in completion

Author: d-biehl

CHANGELOG.md

@@ -4,7 +4,8 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
-- Correct naming for setting `robotcode.syntax.sectionStyle` to `robotcode.syntax.headerStyle`
+- Add a the setting `robotcode.completion.filterDefaultLanguage` to filter english language in completion, if there is another language defined for workspace or in file
+- Correct naming for setting `robotcode.syntax.sectionStyle` to `robotcode.completion.headerStyle`
 - Filter singular header forms for robotframework >= 6
 
 ##  0.13.18

package.json

@@ -438,12 +438,6 @@
             "description": "Default setting for where to launch the debug target: internal console, integrated terminal, or external terminal.",
             "scope": "resource"
           },
-          "robotcode.syntax.headerStyle": {
-            "type": "string",
-            "default": null,
-            "markdownDescription": "Defines the header style format. If not defined ```*** {name} ***``` is used.",
-            "scope": "resource"
-          },
           "robotcode.robocop.enabled": {
             "type": "boolean",
             "default": true,
@@ -552,6 +546,18 @@
             "type": "integer",
             "default": 3199,
             "description": "Defines the endport for searching a free port for the documentation server."
+          },
+          "robotcode.completion.filterDefaultLanguage": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Filter default language (English) for completion if there is another language defined.",
+            "scope": "resource"
+          },
+          "robotcode.completion.headerStyle": {
+            "type": "string",
+            "default": null,
+            "markdownDescription": "Defines the header style format. If not defined ```*** {name} ***``` is used.",
+            "scope": "resource"
           }
         }
       }
@@ -943,4 +949,4 @@
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0"
   }
-}
+}

robotcode/language_server/common/text_document.py

@@ -216,13 +216,14 @@ async def get_cache(
 
         reference = self.__get_cache_reference(entry)
 
-        with self._lock:
-            e = self._cache[reference]
-
-        async with e.lock:
-            if not e.has_data:
-                e.data = await entry(self, *args, **kwargs)
-                e.has_data = True
+        # with self._lock:
+        e = self._cache[reference]
+
+        if not e.has_data:
+            async with e.lock:
+                if not e.has_data:
+                    e.data = await entry(self, *args, **kwargs)
+                    e.has_data = True
 
         return cast(_T, e.data)
 

robotcode/language_server/robotframework/configuration.py

@@ -45,9 +45,10 @@ def get_rpa_mode(self) -> Optional[bool]:
         return None
 
 
-@config_section("robotcode.syntax")
+@config_section("robotcode.completion")
 @dataclass
-class SyntaxConfig(ConfigBase):
+class CompletionConfig(ConfigBase):
+    filter_default_language: bool = True
     header_style: Optional[str] = None
 
 
@@ -94,7 +95,7 @@ class DocumentationServerConfig(ConfigBase):
 class RobotCodeConfig(ConfigBase):
     language_server: LanguageServerConfig = field(default_factory=LanguageServerConfig)
     robot: RobotConfig = field(default_factory=RobotConfig)
-    syntax: SyntaxConfig = field(default_factory=SyntaxConfig)
+    syntax: CompletionConfig = field(default_factory=CompletionConfig)
     workspace: WorkspaceConfig = field(default_factory=WorkspaceConfig)
     analysis: AnalysisConfig = field(default_factory=AnalysisConfig)
     documentation_server: DocumentationServerConfig = field(default_factory=DocumentationServerConfig)

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -553,6 +553,7 @@ def __init__(
         document: Optional[TextDocument] = None,
         document_type: Optional[DocumentType] = None,
         languages: Optional[Languages] = None,
+        workspace_languages: Optional[Languages] = None,
     ) -> None:
         super().__init__()
 
@@ -563,6 +564,7 @@ def __init__(
         self._document = weakref.ref(document) if document is not None else None
         self.document_type: Optional[DocumentType] = document_type
         self.languages = languages
+        self.workspace_languages = workspace_languages
 
         self._libraries: OrderedDict[str, LibraryEntry] = OrderedDict()
         self._libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None

robotcode/language_server/robotframework/parts/code_action.py

@@ -61,9 +61,9 @@ class ConvertUriParams(Model):
 </head>
 <body>
   <div id="content">
-    <h1>
+    <h3>
         ${type}: ${message}
-    </h1>
+    </h3>
     <pre>
 ${stacktrace}
     </pre>

robotcode/language_server/robotframework/parts/completion.py

@@ -41,7 +41,7 @@
     TextEdit,
 )
 from ...common.text_document import TextDocument
-from ..configuration import SyntaxConfig
+from ..configuration import CompletionConfig
 from ..diagnostics.entities import VariableDefinitionType
 from ..diagnostics.library_doc import (
     CompleteResultKind,
@@ -81,11 +81,15 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         parent.completion.collect.add(self.collect)
         parent.completion.resolve.add(self.resolve)
 
-    async def get_header_style(self, document: TextDocument) -> str:
+    async def get_config(self, document: TextDocument) -> CompletionConfig:
         if (folder := self.parent.workspace.get_workspace_folder(document.uri)) is not None:
-            config = await self.parent.workspace.get_configuration(SyntaxConfig, folder.uri)
-            if config.header_style is not None:
-                return config.header_style
+            return await self.parent.workspace.get_configuration(CompletionConfig, folder.uri)
+
+        return CompletionConfig()
+
+    async def get_header_style(self, config: CompletionConfig) -> str:
+        if config.header_style is not None:
+            return config.header_style
 
         return DEFAULT_HEADER_STYLE if get_robot_version() < (5, 1) else DEFAULT_HEADER_STYLE_51
 
@@ -116,8 +120,10 @@ async def collect(
 
         model = await self.parent.documents_cache.get_model(document, False)
 
+        config = await self.get_config(document)
+
         return await CompletionCollector(
-            self.parent, document, model, namespace, await self.get_header_style(document)
+            self.parent, document, model, namespace, await self.get_header_style(config), config
         ).collect(
             position,
             context,
@@ -135,8 +141,10 @@ async def resolve(self, sender: Any, completion_item: CompletionItem) -> Complet
                     namespace = await self.parent.documents_cache.get_namespace(document)
                     model = await self.parent.documents_cache.get_model(document, False)
                     if namespace is not None:
+                        config = await self.get_config(document)
+
                         return await CompletionCollector(
-                            self.parent, document, model, namespace, await self.get_header_style(document)
+                            self.parent, document, model, namespace, await self.get_header_style(config), config
                         ).resolve(completion_item)
 
         return completion_item
@@ -231,12 +239,14 @@ def __init__(
         model: ast.AST,
         namespace: Namespace,
         header_style: str,
+        config: CompletionConfig,
     ) -> None:
         self.parent = parent
         self.header_style = header_style
         self.document = document
         self.model = model
         self.namespace = namespace
+        self.config = config
 
     async def _find_methods(self, cls: Type[Any]) -> AsyncGenerator[_CompleteMethod, None]:
         if cls is ast.AST:
@@ -399,7 +409,16 @@ async def create_headers_completion_items(self, range: Optional[Range]) -> List[
         if self.namespace.languages is None:
             headers: Iterable[str] = HEADERS
         else:
-            headers = itertools.chain(*(lang.headers for lang in self.namespace.languages))
+            languages = self.namespace.languages.languages
+
+            if (
+                self.config.filter_default_language
+                and len(self.namespace.languages.languages) > 1
+                and self.config.filter_default_language
+            ):
+                languages = [v for v in languages if v.code != "en"]
+
+            headers = itertools.chain(*(lang.headers.keys() for lang in languages))
 
         return [
             CompletionItem(
@@ -419,7 +438,7 @@ async def create_headers_completion_items(self, range: Optional[Range]) -> List[
                 if range is not None
                 else None,
             )
-            for s in ((self.header_style.format(name=k), k) for k in headers)
+            for s in ((self.header_style.format(name=k), k) for k in (v.title() for v in headers))
         ]
 
     async def create_environment_variables_completion_items(self, range: Optional[Range]) -> List[CompletionItem]:
@@ -491,13 +510,27 @@ async def create_settings_completion_items(self, range: Optional[Range]) -> List
         settings = {*settings_class.names, *settings_class.aliases.keys()}
 
         if self.namespace.languages is not None:
-            settings = {k for k, v in self.namespace.languages.settings.items() if v in settings}
+
+            if self.config.filter_default_language and len(self.namespace.languages.languages) > 1:
+                languages = self.namespace.languages.languages
+
+                if self.config.filter_default_language:
+                    languages = [v for v in languages if v.code != "en"]
+
+                items: Iterable[Tuple[str, str]] = itertools.chain(*(lang.settings.items() for lang in languages))
+            else:
+                items = self.namespace.languages.settings.items()
+
+            settings = {k.title() for k, v in items if v in settings}
 
         return [
             CompletionItem(
                 label=setting,
                 kind=CompletionItemKind.KEYWORD,
                 detail="Setting",
+                documentation=self.namespace.languages.settings.get(setting)
+                if self.namespace.languages is not None
+                else None,
                 sort_text=f"090_{setting}",
                 insert_text_format=InsertTextFormat.PLAINTEXT,
                 text_edit=TextEdit(range=range, new_text=setting) if range is not None else None,
@@ -525,12 +558,26 @@ async def create_testcase_settings_completion_items(self, range: Optional[Range]
         settings = {*TestCaseSettings.names, *TestCaseSettings.aliases.keys()}
 
         if self.namespace.languages is not None:
-            settings = {k for k, v in self.namespace.languages.settings.items() if v in settings}
+
+            if self.config.filter_default_language and len(self.namespace.languages.languages) > 1:
+                languages = self.namespace.languages.languages
+
+                if self.config.filter_default_language:
+                    languages = [v for v in languages if v.code != "en"]
+
+                items: Iterable[Tuple[str, str]] = itertools.chain(*(lang.settings.items() for lang in languages))
+            else:
+                items = self.namespace.languages.settings.items()
+
+            settings = {k.title() for k, v in items if v in settings}
 
         return [
             CompletionItem(
                 label=f"[{setting}]",
                 kind=CompletionItemKind.KEYWORD,
+                documentation=self.namespace.languages.settings.get(setting)
+                if self.namespace.languages is not None
+                else None,
                 detail="Setting",
                 sort_text=f"070_{setting}",
                 insert_text_format=InsertTextFormat.PLAINTEXT,
@@ -563,12 +610,26 @@ async def create_keyword_settings_completion_items(self, range: Optional[Range])
         settings = {*KeywordSettings.names, *KeywordSettings.aliases.keys()}
 
         if self.namespace.languages is not None:
-            settings = {k for k, v in self.namespace.languages.settings.items() if v in settings}
+
+            if self.config.filter_default_language and len(self.namespace.languages.languages) > 1:
+                languages = self.namespace.languages.languages
+
+                if self.config.filter_default_language:
+                    languages = [v for v in languages if v.code != "en"]
+
+                items: Iterable[Tuple[str, str]] = itertools.chain(*(lang.settings.items() for lang in languages))
+            else:
+                items = self.namespace.languages.settings.items()
+
+            settings = {k.title() for k, v in items if v in settings}
 
         return [
             CompletionItem(
                 label=f"[{setting}]",
                 kind=CompletionItemKind.KEYWORD,
+                documentation=self.namespace.languages.settings.get(setting)
+                if self.namespace.languages is not None
+                else None,
                 detail="Setting",
                 sort_text=f"070_{setting}",
                 insert_text_format=InsertTextFormat.PLAINTEXT,

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -11,6 +11,7 @@
     Iterable,
     List,
     Optional,
+    Tuple,
     Union,
     cast,
 )
@@ -93,23 +94,28 @@ async def get_workspace_languages(self, document_or_uri: Union[TextDocument, Uri
 
         return cast(Languages, RobotLanguages(result.languages))
 
-    async def build_languages_from_model(self, document: TextDocument, model: ast.AST) -> Optional[Languages]:
+    async def build_languages_from_model(
+        self, document: TextDocument, model: ast.AST
+    ) -> Tuple[Optional[Languages], Optional[Languages]]:
         if get_robot_version() < (5, 1):
-            return None
+            return (None, None)
 
         from robot.conf.languages import Languages as RobotLanguages
         from robot.parsing.model.blocks import File
 
         workspace_langs = await self.get_workspace_languages(document)
 
-        return cast(
-            Languages,
-            RobotLanguages(
-                [
-                    *(workspace_langs.languages if workspace_langs else []),
-                    *(model.languages if isinstance(model, File) else []),
-                ]
+        return (
+            cast(
+                Languages,
+                RobotLanguages(
+                    [
+                        *(workspace_langs.languages if workspace_langs else []),
+                        *(model.languages if isinstance(model, File) else []),
+                    ]
+                ),
             ),
+            workspace_langs,
         )
 
     async def get_document_type(self, document: TextDocument) -> DocumentType:
@@ -405,9 +411,11 @@ async def __get_namespace_for_document_type(
 
         imports_manager = await self.get_imports_manager(document)
 
-        languages = await self.build_languages_from_model(document, model)
+        languages, workspace_languages = await self.build_languages_from_model(document, model)
 
-        result = Namespace(imports_manager, model, str(document.uri.to_path()), document, document_type, languages)
+        result = Namespace(
+            imports_manager, model, str(document.uri.to_path()), document, document_type, languages, workspace_languages
+        )
         result.has_invalidated.add(self.__invalidate_namespace)
         result.has_imports_changed.add(self.__invalidate_namespace)