Delimiter pairs

core/edit/delimiter_pair.py

@@ -0,0 +1,32 @@
+from talon import Module, actions
+
+mod = Module()
+
+mod.list("delimiter_pair", "List of matching pair delimiters")
+
+
+@mod.capture(rule="{user.delimiter_pair}")
+def delimiter_pair(m) -> list[str]:
+    pair = m.delimiter_pair.split()
+    assert len(pair) == 2
+    open = pair[0] if pair[0] != "space" else " "
+    close = pair[1] if pair[1] != "space" else " "
+    return [open, close]
+
+
+@mod.action_class
+class Actions:
+    def delimiter_pair_insert(pair: list[str]):
+        """Insert a delimiter pair <pair> leaving the cursor in the middle"""
+        left, right = pair
+        actions.insert(f"{left}{right}")
+        for _ in right:
+            actions.edit.left()
+
+    def delimiter_pair_wrap_selection(pair: list[str]):
+        """Wrap selection with delimiter pair <pair>"""
+        left, right = pair
+        selected = actions.edit.selected_text()
+        actions.insert(f"{left}{selected}{right}")
+        for _ in right:
+            actions.edit.left()

core/edit/delimiter_pair.talon-list

@@ -0,0 +1,11 @@
+list: user.delimiter_pair
+-
+
+round: ( )
+index: [ ]
+diamond: < >
+curly: { }
+twin: "' '"
+quad: '" "'
+skis: ` `
+padding: space space

core/edit/edit.talon

@@ -125,12 +125,14 @@ new line above: edit.line_insert_up()
 new line below | slap: edit.line_insert_down()
 
 # Insert padding with optional symbols
-(pad | padding): user.insert_between(" ", " ")
 (pad | padding) <user.symbol_key>+:
     insert(" ")
     user.insert_many(symbol_key_list)
     insert(" ")
 
+# Insert delimiter pairs
+<user.delimiter_pair>: user.delimiter_pair_insert(delimiter_pair)
+
 # Undo/redo
 undo that: edit.undo()
 redo that: edit.redo()

core/edit/edit_command_actions.py

@@ -1,36 +1,66 @@
 from dataclasses import dataclass
-from typing import Callable
+from typing import Callable, Union
 
 from talon import Module, actions
 
 
 @dataclass
-class EditAction:
+class EditSimpleAction:
     type: str
 
+    def __str__(self):
+        return self.type
+
 
 @dataclass
-class EditInsertAction(EditAction):
+class EditInsertAction:
     type = "insert"
     text: str
 
+    def __str__(self):
+        return self.type
+
+
+@dataclass
+class EditWrapAction:
+    type = "wrapWithDelimiterPair"
+    pair: list[str]
+
+    def __str__(self):
+        return self.type
+
 
 @dataclass
-class EditFormatAction(EditAction):
+class EditFormatAction:
     type = "applyFormatter"
     formatters: str
 
+    def __str__(self):
+        return self.type
+
+
+EditAction = Union[
+    EditSimpleAction,
+    EditInsertAction,
+    EditWrapAction,
+    EditFormatAction,
+]
 
 mod = Module()
 mod.list("edit_action", desc="Actions for the edit command")
 
 
 @mod.capture(rule="{user.edit_action}")
-def edit_simple_action(m) -> EditAction:
-    return EditAction(m.edit_action)
+def edit_simple_action(m) -> EditSimpleAction:
+    return EditSimpleAction(m.edit_action)
+
 
+@mod.capture(rule="<user.delimiter_pair> wrap")
+def edit_wrap_action(m) -> EditWrapAction:
+    return EditWrapAction(m.delimiter_pair)
 
-@mod.capture(rule="<user.edit_simple_action>")
+
+@mod.capture(rule="<user.edit_simple_action> | <user.edit_wrap_action>")
 def edit_action(m) -> EditAction:
     return m[0]
 
@@ -62,6 +92,10 @@ def run_action_callback(action: EditAction):
             assert isinstance(action, EditInsertAction)
             actions.insert(action.text)
 
+        case "wrapWithDelimiterPair":
+            assert isinstance(action, EditWrapAction)
+            return lambda: actions.user.delimiter_pair_wrap_selection(action.pair)
+
         case "applyFormatter":
             assert isinstance(action, EditFormatAction)
             actions.user.formatters_reformat_selection(action.formatters)