refactor: move code_actions and support unions with enums and string in dataclasses

Author: d-biehl

packages/core/src/robotcode/core/dataclasses.py

@@ -228,6 +228,11 @@ def from_dict(
 
             continue
 
+        if inspect.isclass(origin or t) and issubclass(origin or t, enum.Enum):
+            for v in cast(Iterable[Any], t):
+                if v.value == value:
+                    return cast(_T, v)
+
         if (
             t is Any
             or t is Ellipsis  # type: ignore

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

@@ -1406,7 +1406,7 @@ def evaluate(
             return EvaluateResult(result="")
 
         if (
-            (context == EvaluateArgumentContext.REPL or context == EvaluateArgumentContext.REPL.value)
+            (context == EvaluateArgumentContext.REPL)
             and expression.startswith("#")
             and expression[1:].strip() == "exprmode"
         ):
@@ -1436,7 +1436,6 @@ def evaluate(
             if (
                 isinstance(context, EvaluateArgumentContext)
                 and context != EvaluateArgumentContext.REPL
-                or context != EvaluateArgumentContext.REPL.value
                 or self.expression_mode
             ):
                 if expression.startswith("! "):

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

@@ -1,5 +1,7 @@
 from typing import Any, Callable, List, Protocol, TypeVar, Union, runtime_checkable
 
+from robotcode.core.lsp.types import CodeActionKind
+
 from .text_document import TextDocument
 
 _F = TypeVar("_F", bound=Callable[..., Any])
@@ -66,9 +68,9 @@ class HasAllCommitCharacters(Protocol):
 CODE_ACTION_KINDS_ATTR = "__code_action_kinds__"
 
 
-def code_action_kinds(characters: List[str]) -> Callable[[_F], _F]:
+def code_action_kinds(kinds: List[Union[CodeActionKind, str]]) -> Callable[[_F], _F]:
     def decorator(func: _F) -> _F:
-        setattr(func, CODE_ACTION_KINDS_ATTR, characters)
+        setattr(func, CODE_ACTION_KINDS_ATTR, kinds)
         return func
 
     return decorator
@@ -93,23 +95,23 @@ def filter(c: Any) -> bool:
     return filter
 
 
-COMMAND_NAME_ATTR = "__command_name__"
+COMMAND_ID_ATTR = "__command_name__"
 
 
-def command(name: str) -> Callable[[_F], _F]:
+def command(id: str) -> Callable[[_F], _F]:
     def decorator(func: _F) -> _F:
-        setattr(func, COMMAND_NAME_ATTR, name)
+        setattr(func, COMMAND_ID_ATTR, id)
         return func
 
     return decorator
 
 
 def is_command(func: Callable[..., Any]) -> bool:
-    return hasattr(func, COMMAND_NAME_ATTR)
+    return hasattr(func, COMMAND_ID_ATTR)
 
 
-def get_command_name(func: Callable[..., Any]) -> str:
-    if hasattr(func, COMMAND_NAME_ATTR):
-        return str(getattr(func, COMMAND_NAME_ATTR))
+def get_command_id(func: Callable[..., Any]) -> str:
+    if hasattr(func, COMMAND_ID_ATTR):
+        return str(getattr(func, COMMAND_ID_ATTR))
 
     raise TypeError(f"{func} is not a command.")

packages/language_server/src/robotcode/language_server/common/parts/commands.py

@@ -17,7 +17,7 @@
     ServerCapabilities,
 )
 from robotcode.jsonrpc2.protocol import JsonRPCErrorException, rpc_method
-from robotcode.language_server.common.decorators import get_command_name, is_command
+from robotcode.language_server.common.decorators import get_command_id, is_command
 from robotcode.language_server.common.has_extend_capabilities import HasExtendCapabilities
 from robotcode.language_server.common.parts.protocol_part import LanguageServerProtocolPart
 
@@ -44,7 +44,7 @@ def __init__(self, parent: LanguageServerProtocol) -> None:
         self.commands: Dict[str, CommandEntry] = {}
 
     def register(self, callback: _FUNC_TYPE, name: Optional[str] = None) -> str:
-        name = name or get_command_name(callback)
+        name = name or get_command_id(callback)
 
         command = f"{self.PREFIX}.{name}"
 
@@ -64,7 +64,7 @@ def register_all(self, instance: object) -> None:
                 self.register(cast(_FUNC_TYPE, method))
 
     def get_command_name(self, callback: _FUNC_TYPE, name: Optional[str] = None) -> str:
-        name = name or get_command_name(callback)
+        name = name or get_command_id(callback)
 
         return f"{self.PREFIX}.{name}"
 

…obotframework/parts/code_action_fixes.py …amework/parts/code_action_quick_fixes.pypackages/language_server/src/robotcode/language_server/robotframework/parts/code_action_fixes.py renamed to packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_quick_fixes.py packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_fixes.py renamed to packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -20,10 +20,11 @@
     TextDocumentEdit,
     WorkspaceEdit,
 )
+from robotcode.core.utils.inspect import iter_methods
 from robotcode.language_server.common.decorators import code_action_kinds, command, language_id
 from robotcode.language_server.common.text_document import TextDocument
 from robotcode.language_server.robotframework.utils.ast_utils import Token, get_node_at_position, range_from_node
-from robotcode.language_server.robotframework.utils.async_ast import AsyncVisitor
+from robotcode.language_server.robotframework.utils.async_ast import Visitor
 
 from .model_helper import ModelHelperMixin
 from .protocol_part import RobotLanguageServerProtocolPart
@@ -32,9 +33,6 @@
     from robotcode.language_server.robotframework.protocol import RobotLanguageServerProtocol  # pragma: no cover
 
 
-CODEACTIONKIND_QUICKFIX_CREATEKEYWORD = f"{CodeActionKind.QUICK_FIX.value}.createKeyword"
-
-
 KEYWORD_WITH_ARGS_TEMPLATE = Template(
     """\
 ${name}
@@ -55,17 +53,17 @@
 )
 
 
-class FindKeywordSectionVisitor(AsyncVisitor):
+class FindKeywordSectionVisitor(Visitor):
     def __init__(self) -> None:
         self.keyword_sections: List[ast.AST] = []
 
-    async def visit_KeywordSection(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_KeywordSection(self, node: ast.AST) -> None:  # noqa: N802
         self.keyword_sections.append(node)
 
 
-async def find_keyword_sections(node: ast.AST) -> Optional[List[ast.AST]]:
+def find_keyword_sections(node: ast.AST) -> Optional[List[ast.AST]]:
     visitor = FindKeywordSectionVisitor()
-    await visitor.visit(node)
+    visitor.visit(node)
     return visitor.keyword_sections if visitor.keyword_sections else None
 
 
@@ -80,14 +78,23 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self.parent.commands.register_all(self)
 
     @language_id("robotframework")
-    @code_action_kinds(
-        [
-            CODEACTIONKIND_QUICKFIX_CREATEKEYWORD,
-        ]
-    )
-    @_logger.call
+    @code_action_kinds([CodeActionKind.QUICK_FIX])
     async def collect(
         self, sender: Any, document: TextDocument, range: Range, context: CodeActionContext
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        result = []
+        for method in iter_methods(self, lambda m: m.__name__.startswith("code_action_")):
+            code_actions = await method(self, document, range, context)
+            if code_actions:
+                result.extend(code_actions)
+
+        if result:
+            return result
+
+        return None
+
+    async def code_action_create_keyword(
+        self, sender: Any, document: TextDocument, range: Range, context: CodeActionContext
     ) -> Optional[List[Union[Command, CodeAction]]]:
         kw_not_found_in_diagnostics = next((d for d in context.diagnostics if d.code == "KeywordNotFoundError"), None)
 
@@ -98,11 +105,11 @@ async def collect(
             return [
                 CodeAction(
                     "Create Keyword",
-                    kind=CodeActionKind.QUICK_FIX.value + ".createKeyword",
+                    kind=CodeActionKind.QUICK_FIX,
                     command=Command(
-                        "Create Keyword",
-                        self.parent.commands.get_command_name(self.create_keyword),
-                        [document.document_uri, range, context],
+                        self.parent.commands.get_command_name(self.create_keyword_command),
+                        self.parent.commands.get_command_name(self.create_keyword_command),
+                        [document.document_uri, range],
                     ),
                     diagnostics=[kw_not_found_in_diagnostics],
                 )
@@ -111,7 +118,7 @@ async def collect(
         return None
 
     @command("robotcode.createKeyword")
-    async def create_keyword(self, document_uri: DocumentUri, range: Range, context: CodeActionContext) -> None:
+    async def create_keyword_command(self, document_uri: DocumentUri, range: Range) -> None:
         from robot.parsing.lexer import Token as RobotToken
         from robot.parsing.model.statements import (
             Fixture,
@@ -162,7 +169,7 @@ async def create_keyword(self, document_uri: DocumentUri, range: Range, context:
                 else KEYWORD_TEMPLATE.substitute(name=keyword)
             )
 
-            keyword_sections = await find_keyword_sections(model)
+            keyword_sections = find_keyword_sections(model)
             keyword_section = keyword_sections[-1] if keyword_sections else None
 
             if keyword_section is not None:

packages/language_server/src/robotcode/language_server/robotframework/protocol.py

@@ -15,7 +15,7 @@
 from ..__version__ import __version__
 from .configuration import RobotConfig
 from .parts.code_action_documentation import RobotCodeActionDocumentationProtocolPart
-from .parts.code_action_fixes import RobotCodeActionFixesProtocolPart
+from .parts.code_action_quick_fixes import RobotCodeActionFixesProtocolPart
 from .parts.codelens import RobotCodeLensProtocolPart
 from .parts.completion import RobotCompletionProtocolPart
 from .parts.debugging_utils import RobotDebuggingUtilsProtocolPart

tests/robotcode/core/test_dataclasses.py

@@ -203,6 +203,7 @@ def test_encode_with_optional_field_and_none_as_default_value() -> None:
         ('"first"', EnumData, EnumData.FIRST),
         ('"second"', EnumData, EnumData.SECOND),
         ('["first", "second"]', List[EnumData], [EnumData.FIRST, EnumData.SECOND]),
+        ('["first", "second", "ninety"]', List[Union[EnumData, str]], [EnumData.FIRST, EnumData.SECOND, "ninety"]),
     ],
 )
 def test_decode_simple(expr: Any, type: Any, expected: str) -> None: