correct completion of bdd prefixes

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -1431,11 +1431,12 @@ async def get_keywords(self) -> List[KeywordDoc]:
                     current_time = time.monotonic()
                     self._logger.debug("start collecting keywords")
                     try:
+                        i = 0
+
                         await self.ensure_initialized()
 
                         result: Dict[KeywordMatcher, KeywordDoc] = {}
 
-                        i = 0
                         async for doc in self.iter_all_keywords():
                             i += 1
                             result[KeywordMatcher(doc.name)] = doc

robotcode/language_server/robotframework/parts/completion.py

@@ -466,6 +466,24 @@ async def create_testcase_settings_completion_items(self, range: Optional[Range]
             for setting in settings
         ]
 
+    async def create_bdd_prefix_completion_items(self, range: Optional[Range]) -> List[CompletionItem]:
+        prefixes = {"Given", "When", "Then", "And", "But"}
+
+        if self.namespace.languages is not None:
+            prefixes.update(self.namespace.languages.bdd_prefixes)
+
+        return [
+            CompletionItem(
+                label=prefix,
+                kind=CompletionItemKind.UNIT,
+                detail="BDD Prefix",
+                sort_text=f"080_{prefix}",
+                insert_text_format=InsertTextFormat.PLAINTEXT,
+                text_edit=TextEdit(range=range, new_text=f"{prefix} ") if range is not None else None,
+            )
+            for prefix in prefixes
+        ]
+
     async def create_keyword_settings_completion_items(self, range: Optional[Range]) -> List[CompletionItem]:
         from robot.parsing.lexer.settings import KeywordSettings
 
@@ -521,13 +539,30 @@ async def create_keyword_completion_items(
         add_reserverd: bool = True,
         add_none: bool = False,
         in_template: bool = False,
+        add_bdd_prefixes: bool = True,
     ) -> List[CompletionItem]:
         result: List[CompletionItem] = []
         if self.document is None:
             return []
 
         r: Optional[Range] = None
 
+        has_bdd = False
+        bdd_token = None
+
+        if token is not None:
+            old_token = token
+            bdd_token, token = self.split_bdd_prefix(self.namespace, token)
+
+            if token is not None and token.value == "":
+                token = None
+
+            if bdd_token is not None and position.character > range_from_token(bdd_token).end.character:
+                has_bdd = True
+
+            if not has_bdd and token is None:
+                token = old_token
+
         if token is not None:
             r = range_from_token(token)
 
@@ -708,6 +743,11 @@ def enumerate_indexes(s: str, c: str) -> Iterator[int]:
                 )
             )
 
+        if add_bdd_prefixes and not has_bdd:
+            result += await self.create_bdd_prefix_completion_items(
+                range_from_token(token) if token is not None else None
+            )
+
         if add_reserverd:
             for k in get_reserved_keywords():
                 result.append(
@@ -934,8 +974,6 @@ async def _complete_TestCase_or_Keyword(  # noqa: N802
             if len(statement_node.tokens) > index:
                 token = statement_node.tokens[index]
 
-                token = self.strip_bdd_prefix(self.namespace, token)
-
                 r = range_from_token(token)
                 if position.is_in_range(r):
                     return await create_items(in_assign, in_template, r, token, position)
@@ -952,7 +990,7 @@ async def _complete_TestCase_or_Keyword(  # noqa: N802
                             in_assign,
                             in_template,
                             r,
-                            None if self.is_bdd_token(self.namespace, token) else token,
+                            token,
                             position,
                         )
 
@@ -1080,7 +1118,7 @@ async def _complete_SuiteSetup_or_SuiteTeardown_or_TestTemplate(  # noqa: N802
             r = range_from_token(token)
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(self.namespace, token) else token,
+                    token,
                     position,
                     add_reserverd=False,
                     add_none=True,
@@ -1096,7 +1134,7 @@ async def _complete_SuiteSetup_or_SuiteTeardown_or_TestTemplate(  # noqa: N802
             r.end.character += 1
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(self.namespace, token) else token,
+                    token,
                     position,
                     add_reserverd=False,
                     add_none=True,
@@ -1223,7 +1261,7 @@ async def complete_Setup_or_Teardown_or_Template(  # noqa: N802
             r.end.character += 1
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(self.namespace, token) else token,
+                    token,
                     position,
                     add_reserverd=False,
                     add_none=True,

robotcode/language_server/robotframework/parts/model_helper.py

@@ -492,6 +492,41 @@ def get_expression_statement_types(cls) -> Tuple[Type[Any]]:
     BDD_TOKEN_REGEX = re.compile(r"^(Given|When|Then|And|But)\s", flags=re.IGNORECASE)
     BDD_TOKEN = re.compile(r"^(Given|When|Then|And|But)$", flags=re.IGNORECASE)
 
+    @classmethod
+    def split_bdd_prefix(cls, namespace: Namespace, token: Token) -> Tuple[Optional[Token], Optional[Token]]:
+        from robot.parsing.lexer import Token as RobotToken
+
+        bdd_token = None
+
+        parts = token.value.split(maxsplit=1)
+        if len(parts) < 1:
+            return None, token
+
+        prefix = parts[0]
+        if prefix.title() in (
+            namespace.languages.bdd_prefixes
+            if namespace.languages is not None
+            else {"Given ", "When ", "Then ", "And ", "But "}
+        ):
+            bdd_len = len(prefix)
+            bdd_token = RobotToken(
+                token.type,
+                token.value[:bdd_len],
+                token.lineno,
+                token.col_offset,
+                token.error,
+            )
+
+            token = RobotToken(
+                token.type,
+                token.value[bdd_len + 1 :],
+                token.lineno,
+                token.col_offset + bdd_len + 1,
+                token.error,
+            )
+
+        return bdd_token, token
+
     @classmethod
     def strip_bdd_prefix(cls, namespace: Namespace, token: Token) -> Token:
         from robot.parsing.lexer import Token as RobotToken
@@ -514,7 +549,7 @@ def strip_bdd_prefix(cls, namespace: Namespace, token: Token) -> Token:
             if len(parts) < 2:
                 return token
 
-            prefix, _ = parts
+            prefix = parts[0]
             if prefix.title() in (
                 namespace.languages.bdd_prefixes
                 if namespace.languages is not None
@@ -538,10 +573,11 @@ def is_bdd_token(cls, namespace: Namespace, token: Token) -> bool:
             return bool(bdd_match)
         else:
             parts = token.value.split(maxsplit=1)
-            if len(parts) < 2:
+            if len(parts) < 1:
                 return False
 
-            prefix, _ = parts
+            prefix = parts[0]
+
             if prefix.title() in (
                 namespace.languages.bdd_prefixes
                 if namespace.languages is not None