Support forced language mode for snippets

Author: AndreasArvidsson

cursorless-talon/src/command.py

@@ -94,6 +94,8 @@ def make_serializable(value: Any) -> Any:
         return {k: make_serializable(v) for k, v in value.items()}
     if isinstance(value, list):
         return [make_serializable(v) for v in value]
+    if isinstance(value, staticmethod):
+        return None
     if dataclasses.is_dataclass(value):
         items = {
             **{

cursorless-talon/src/cursorless.talon

@@ -24,6 +24,12 @@ tag: user.cursorless
 <user.cursorless_wrapper_paired_delimiter> {user.cursorless_wrap_action} <user.cursorless_target>:
     user.private_cursorless_wrap_with_paired_delimiter(cursorless_wrap_action, cursorless_target, cursorless_wrapper_paired_delimiter)
 
+{user.cursorless_insert_snippet_action} {user.snippet} <user.cursorless_destination>:
+    user.private_cursorless_insert_community_snippet(snippet, cursorless_destination)
+
+{user.snippet_wrapper} {user.cursorless_wrap_action} <user.cursorless_target>:
+    user.private_cursorless_wrap_with_community_snippet(snippet_wrapper, cursorless_target)
+
 {user.cursorless_show_scope_visualizer} <user.cursorless_scope_type> [{user.cursorless_visualization_type}]:
     user.private_cursorless_show_scope_visualizer(cursorless_scope_type, cursorless_visualization_type or "content")
 {user.cursorless_hide_scope_visualizer}:

cursorless-talon/src/snippets.talon

@@ -1,13 +1,41 @@
 from dataclasses import dataclass
 
-from .targets.target_types import CursorlessDestination, CursorlessTarget
+from ..targets.target_types import CursorlessDestination, CursorlessTarget
+
+# Scope types
 
 
 @dataclass
 class ScopeType:
     type: str
 
 
+def to_scope_types(scope_types: str | list[str] | None) -> list[ScopeType] | None:
+    if isinstance(scope_types, str):
+        return [ScopeType(scope_types)]
+    elif scope_types is not None:
+        return [ScopeType(st) for st in scope_types]
+    return None
+
+
+# Community types
+
+
+@dataclass
+class CommunityInsertionSnippet:
+    body: str
+    languages: list[str] | None = None
+    scopes: list[str] | None = None
+
+
+@dataclass
+class CommunityWrapperSnippet:
+    body: str
+    variable_name: str
+    languages: list[str] | None
+    scope: str | None
+
+
 # Insertion snippets
 
 
@@ -19,6 +47,19 @@ class CustomInsertionSnippet:
     languages: list[str] | None
     substitutions: dict[str, str] | None
 
+    @staticmethod
+    def create(
+        snippet: CommunityInsertionSnippet,
+        substitutions: dict[str, str] | None,
+    ):
+        return CustomInsertionSnippet(
+            snippet.body,
+            to_scope_types(snippet.scopes),
+            # languages will be missing if the user has an older version of community
+            snippet.languages if hasattr(snippet, "languages") else None,
+            substitutions=substitutions,
+        )
+
 
 @dataclass
 class ListInsertionSnippet:
@@ -45,6 +86,16 @@ class CustomWrapperSnippet:
     scopeType: ScopeType | None
     languages: list[str] | None
 
+    @staticmethod
+    def create(snippet: CommunityWrapperSnippet):
+        return CustomWrapperSnippet(
+            snippet.body,
+            snippet.variable_name,
+            ScopeType(snippet.scope) if snippet.scope else None,
+            # languages will be missing if the user has an older version of community
+            snippet.languages if hasattr(snippet, "languages") else None,
+        )
+
 
 @dataclass
 class ListWrapperSnippet:
@@ -57,21 +108,3 @@ class WrapperSnippetAction:
     name = "wrapWithSnippet"
     snippetDescription: CustomWrapperSnippet | ListWrapperSnippet
     target: CursorlessTarget
-
-
-# Community types
-
-
-@dataclass
-class CommunityInsertionSnippet:
-    body: str
-    languages: list[str] | None = None
-    scopes: list[str] | None = None
-
-
-@dataclass
-class CommunityWrapperSnippet:
-    body: str
-    variable_name: str
-    languages: list[str] | None
-    scope: str | None

cursorless-talon/src/snippet_types.py renamed to cursorless-talon/src/snippets/snippet_types.py

@@ -2,26 +2,35 @@
 
 from talon import Context, Module, actions
 
+from ..targets.target_types import (
+    CursorlessDestination,
+    CursorlessTarget,
+    ImplicitDestination,
+)
 from .snippet_types import (
-    CommunityInsertionSnippet,
-    CommunityWrapperSnippet,
     CustomInsertionSnippet,
     CustomWrapperSnippet,
     InsertSnippetAction,
     ListInsertionSnippet,
     ListWrapperSnippet,
     ScopeType,
     WrapperSnippetAction,
+    to_scope_types,
 )
-from .targets.target_types import (
-    CursorlessDestination,
-    CursorlessTarget,
-    ImplicitDestination,
+from .snippets_get import (
+    get_custom_insertion_snippets,
+    get_custom_wrapper_snippet,
+    get_insertion_snippet,
+    get_wrapper_snippet,
 )
 
 mod = Module()
 ctx = Context()
 
+ctx.matches = r"""
+not tag: user.code_language_forced
+"""
+
 mod.list("cursorless_insert_snippet_action", desc="Cursorless insert snippet action")
 
 
@@ -47,50 +56,63 @@ def insert_community_snippet(
     name: str,
     substitutions: dict[str, str] | None,
     destination: CursorlessDestination,
+    use_list: bool,
 ):
-    snippets: list[CommunityInsertionSnippet] = get_insertion_snippets(name)
-    snippet = ListInsertionSnippet(
-        substitutions,
-        [
-            CustomInsertionSnippet(
-                s.body,
-                to_scope_types(s.scopes),
-                # languages will be missing if the user has an older version of community
-                s.languages if hasattr(s, "languages") else None,
-                substitutions=None,
-            )
-            for s in snippets
-        ],
+    snippet = (
+        get_insertion_snippet(name, substitutions)
+        if use_list
+        else get_custom_insertion_snippets(name, substitutions)
     )
     insert_snippet(snippet, destination)
 
 
-def insert_community_wrapper_snippet(name: str, target: CursorlessTarget):
-    snippets: list[CommunityWrapperSnippet] = get_wrapper_snippets(name)
-    snippet = ListWrapperSnippet(
-        [
-            CustomWrapperSnippet(
-                s.body,
-                s.variable_name,
-                ScopeType(s.scope) if s.scope else None,
-                s.languages if hasattr(s, "languages") else None,
-            )
-            for s in snippets
-        ],
+def wrap_with_community_snippet(
+    name: str,
+    target: CursorlessTarget,
+    use_list: bool,
+):
+    snippet = (
+        get_wrapper_snippet(name) if use_list else get_custom_wrapper_snippet(name)
     )
     wrap_with_snippet(snippet, target)
 
 
+# These actions use list snippets since no language mode is forced
+
+
 @ctx.action_class("user")
 class UserActions:
     def insert_snippet_by_name(
         name: str,  # pyright: ignore [reportGeneralTypeIssues]
+        # Don't add optional; We need to match the type in community
         substitutions: dict[str, str] = None,
     ):
         insert_community_snippet(
             name,
             substitutions,
             ImplicitDestination(),
+            use_list=True,
+        )
+
+    def private_cursorless_insert_community_snippet(
+        name: str,  # pyright: ignore [reportGeneralTypeIssues]
+        destination: CursorlessDestination,
+    ):
+        insert_community_snippet(
+            name,
+            substitutions=None,
+            destination=destination,
+            use_list=True,
+        )
+
+    def private_cursorless_wrap_with_community_snippet(
+        name: str,  # pyright: ignore [reportGeneralTypeIssues]
+        target: CursorlessTarget,
+    ):
+        wrap_with_community_snippet(
+            name,
+            target,
+            use_list=True,
         )
 
 
@@ -125,6 +147,8 @@ def cursorless_wrap_with_snippet(
         )
         wrap_with_snippet(snippet, target)
 
+    # These actions use a single custom snippets since a language mode is forced
+
     def private_cursorless_insert_community_snippet(
         name: str,  # pyright: ignore [reportGeneralTypeIssues]
         destination: CursorlessDestination,
@@ -134,39 +158,16 @@ def private_cursorless_insert_community_snippet(
             name,
             substitutions=None,
             destination=destination,
+            use_list=False,
         )
 
     def private_cursorless_wrap_with_community_snippet(
         name: str,  # pyright: ignore [reportGeneralTypeIssues]
         target: CursorlessTarget,
     ):
         """Cursorless: Wrap target with community snippet <name>"""
-        insert_community_wrapper_snippet(name, target)
-
-
-def to_scope_types(scope_types: str | list[str] | None) -> list[ScopeType] | None:
-    if isinstance(scope_types, str):
-        return [ScopeType(scope_types)]
-    elif scope_types is not None:
-        return [ScopeType(st) for st in scope_types]
-    return None
-
-
-def get_insertion_snippets(name: str) -> list[CommunityInsertionSnippet]:
-    try:
-        return actions.user.get_insertion_snippets(name)
-    except Exception as ex:
-        if isinstance(ex, KeyError):
-            snippet = actions.user.get_insertion_snippet(name)
-            return [snippet]
-        raise
-
-
-def get_wrapper_snippets(name: str) -> list[CommunityWrapperSnippet]:
-    try:
-        return actions.user.get_wrapper_snippets(name)
-    except Exception as ex:
-        if isinstance(ex, KeyError):
-            snippet = actions.user.get_wrapper_snippet(name)
-            return [snippet]
-        raise
+        wrap_with_community_snippet(
+            name,
+            target,
+            use_list=False,
+        )

cursorless-talon/src/snippets.py renamed to cursorless-talon/src/snippets/snippets.py

@@ -0,0 +1,64 @@
+from talon import actions
+
+from .snippet_types import (
+    CommunityInsertionSnippet,
+    CommunityWrapperSnippet,
+    CustomInsertionSnippet,
+    CustomWrapperSnippet,
+    ListInsertionSnippet,
+    ListWrapperSnippet,
+)
+
+
+def get_insertion_snippet(
+    name: str,
+    substitutions: dict[str, str] | None,
+) -> ListInsertionSnippet | CustomInsertionSnippet:
+    try:
+        return get_list_insertion_snippets(name, substitutions)
+    except Exception as ex:
+        if isinstance(ex, KeyError):
+            return get_custom_insertion_snippets(name, substitutions)
+        raise
+
+
+def get_list_insertion_snippets(
+    name: str,
+    substitutions: dict[str, str] | None,
+) -> ListInsertionSnippet:
+    snippets: list[CommunityInsertionSnippet] = actions.user.get_insertion_snippets(
+        name
+    )
+    return ListInsertionSnippet(
+        substitutions,
+        [CustomInsertionSnippet.create(s, substitutions=None) for s in snippets],
+    )
+
+
+def get_custom_insertion_snippets(
+    name: str,
+    substitutions: dict[str, str] | None,
+) -> CustomInsertionSnippet:
+    snippet: CommunityInsertionSnippet = actions.user.get_insertion_snippet(name)
+    return CustomInsertionSnippet.create(snippet, substitutions)
+
+
+def get_wrapper_snippet(name: str) -> ListWrapperSnippet | CustomWrapperSnippet:
+    try:
+        return get_list_wrapper_snippet(name)
+    except Exception as ex:
+        if isinstance(ex, KeyError):
+            return get_custom_wrapper_snippet(name)
+        raise
+
+
+def get_list_wrapper_snippet(name: str) -> ListWrapperSnippet:
+    snippets: list[CommunityWrapperSnippet] = actions.user.get_wrapper_snippets(name)
+    return ListWrapperSnippet(
+        [CustomWrapperSnippet.create(s) for s in snippets],
+    )
+
+
+def get_custom_wrapper_snippet(name: str) -> CustomWrapperSnippet:
+    snippet: CommunityWrapperSnippet = actions.user.get_wrapper_snippet(name)
+    return CustomWrapperSnippet.create(snippet)