csv overrides

src/actions/actions.py

@@ -1,43 +1,42 @@
-from talon import Context, Module, actions
+from talon import Module, actions, app
 from dataclasses import dataclass
+from ..csv_overrides import init_csv_and_watch_changes
 from .homophones import run_homophones_action
 from .find import run_find_action
 from .call import run_call_action
 
 mod = Module()
 
-ctx = Context()
-ctx.matches = r"""
-tag: user.cursorless
-"""
-
 
 @dataclass
 class MakeshiftAction:
     term: str
+    identifier: str
     vscode_command_id: str
     pre_command_sleep: float = 0
     post_command_sleep: float = 0
 
 
 makeshift_actions = [
-    MakeshiftAction("drink cell", "jupyter.insertCellAbove"),
-    MakeshiftAction("define", "editor.action.revealDefinition"),
-    MakeshiftAction("hover", "editor.action.showHover"),
-    MakeshiftAction("inspect", "editor.debug.action.showDebugHover"),
-    MakeshiftAction("pour cell", "jupyter.insertCellBelow"),
-    MakeshiftAction("quick fix", "editor.action.quickFix", pre_command_sleep=0.3),
-    MakeshiftAction("reference", "references-view.find"),
-    MakeshiftAction("rename", "editor.action.rename", post_command_sleep=0.1),
+    MakeshiftAction("drink cell", "editNewCellAbove", "jupyter.insertCellAbove"),
+    MakeshiftAction("define", "revealDefinition", "editor.action.revealDefinition"),
+    MakeshiftAction("hover", "showHover", "editor.action.showHover"),
+    MakeshiftAction("inspect", "showDebugHover", "editor.debug.action.showDebugHover"),
+    MakeshiftAction("pour cell", "editNewCellBelow", "jupyter.insertCellBelow"),
+    MakeshiftAction(
+        "quick fix", "quickFix", "editor.action.quickFix", pre_command_sleep=0.3
+    ),
+    MakeshiftAction("reference", "showReferences", "references-view.find"),
+    MakeshiftAction("rename", "rename", "editor.action.rename", post_command_sleep=0.1),
 ]
 
-makeshift_action_map = {action.term: action for action in makeshift_actions}
+makeshift_action_map = {action.identifier: action for action in makeshift_actions}
 
 
 @dataclass
 class CallbackAction:
     term: str
-    action: str
+    identifier: str
     callback: callable
 
 
@@ -47,11 +46,13 @@ class CallbackAction:
     CallbackAction("phones", "nextHomophone", run_homophones_action),
 ]
 
-callbacks_map = {callback.action: callback.callback for callback in callbacks}
+callbacks_map = {callback.identifier: callback.callback for callback in callbacks}
 
 
 mod.list("cursorless_simple_action", desc="Supported actions for cursorless navigation")
-ctx.lists["self.cursorless_simple_action"] = {
+
+
+simple_actions = {
     "bottom": "scrollToBottom",
     "breakpoint": "setBreakpoint",
     "carve": "cut",
@@ -80,8 +81,8 @@ class CallbackAction:
     "sort": "sort",
     "take": "setSelection",
     "unfold": "unfold",
-    **{action.term: action.term for action in makeshift_actions},
-    **{callback.term: callback.action for callback in callbacks},
+    **{action.term: action.identifier for action in makeshift_actions},
+    **{callback.term: callback.identifier for callback in callbacks},
 }
 
 
@@ -104,3 +105,21 @@ def run_makeshift_action(action: str, targets: dict):
     actions.sleep(makeshift_action.pre_command_sleep)
     actions.user.vscode(makeshift_action.vscode_command_id)
     actions.sleep(makeshift_action.post_command_sleep)
+
+
+default_values = {
+    "simple_action": simple_actions,
+    "swap_action": {"swap": "swap"},
+    "move_bring_action": {"bring": "bring", "move": "move"},
+    "wrap_action": {"wrap": "wrap"},
+    "reformat_action": {"format": "reformat"},
+}
+
+ACTION_LIST_NAMES = [f"user.cursorless_{key}" for key in default_values]
+
+
+def on_ready():
+    init_csv_and_watch_changes("actions", default_values)
+
+
+app.register("ready", on_ready)

src/actions/move_bring.py

@@ -1,16 +1,10 @@
+from talon import Module
 from ..primitive_target import STRICT_HERE
-from talon import Context, Module
 
 mod = Module()
 
-ctx = Context()
-ctx.matches = r"""
-tag: user.cursorless
-"""
-
 
 mod.list("cursorless_move_bring_action", desc="Cursorless move or bring actions")
-ctx.lists["self.cursorless_move_bring_action"] = {"bring", "move"}
 
 
 @mod.capture(rule=("<user.cursorless_target> [to <user.cursorless_target>]"))

src/actions/reformat.py

@@ -4,16 +4,15 @@
 
 mod = Module()
 
+mod.list("cursorless_reformat_action", desc="Cursorless reformat action")
+
 
 @mod.action_class
 class Actions:
     def cursorless_reformat(targets: dict, formatters: str):
         """Reformat targets with formatter"""
         texts = get_text(targets, show_decorations=False)
-        updated_texts = list(map(
-            lambda text: actions.user.reformat_text(text, formatters),
-            texts
-        ))
-        actions.user.cursorless_replace(
-            targets, updated_texts
+        updated_texts = list(
+            map(lambda text: actions.user.reformat_text(text, formatters), texts)
         )
+        actions.user.cursorless_replace(targets, updated_texts)

src/actions/swap.py

@@ -1,11 +1,13 @@
-from ..primitive_target import BASE_TARGET
 from talon import Module
+from ..primitive_target import BASE_TARGET
 
 mod = Module()
 
+mod.list("cursorless_swap_action", desc="Cursorless swap action")
+
 
-@mod.capture(rule=("swap [<user.cursorless_target>] with <user.cursorless_target>"))
-def cursorless_swap(m) -> str:
+@mod.capture(rule=("[<user.cursorless_target>] with <user.cursorless_target>"))
+def cursorless_swap_targets(m) -> str:
     target_list = m.cursorless_target_list
 
     if len(target_list) == 1:

src/actions/wrap.py

@@ -3,6 +3,7 @@
 mod = Module()
 ctx = Context()
 
+
 wrappers = {
     "square": ["[", "]"],
     "round": ["(", ")"],
@@ -16,6 +17,7 @@
     "space": [" ", " "],
 }
 
+mod.list("cursorless_wrap_action", desc="Cursorless wrap action")
 mod.list("cursorless_wrapper", desc="Supported wrappers for cursorless wrap action")
 ctx.lists["self.cursorless_wrapper"] = wrappers.keys()
 

src/cheat_sheet.py

@@ -3,6 +3,7 @@
 import re
 import webbrowser
 import math
+from .actions.actions import ACTION_LIST_NAMES
 
 mod = Module()
 mod.mode("cursorless_cheat_sheet", "Mode for showing cursorless cheat sheet gui")
@@ -93,33 +94,27 @@ def draw(self, canvas):
         self.y = get_y(canvas)
         self.w = 0
 
-        simple_actions = get_list(
-            "simple_action",
+        all_actions = {}
+        for name in ACTION_LIST_NAMES:
+            all_actions.update(get_raw_list(name))
+
+        keys = dict_remove_values(all_actions, "bring", "move", "swap", "reformat")
+        make_dict_readable(
+            all_actions,
             {
                 "call": "Call T on S",
-                "define": "Reveal definition",
-                "drink cell": "Edit new cell above",
-                "pour cell": "Edit new cell below",
-                "reference": "Show references",
+                "wrap": '"round" wrap T',
             },
         )
-
-        move_bring = {}
-        for action, desc in get_list("move_bring_action").items():
-            if desc == "Bring":
-                move_bring[f"{action} T1 to T2"] = "Replace T2 with T1"
-                move_bring[f"{action} T"] = "Replace S with T"
-            if desc == "Move":
-                move_bring[f"{action} T1 to T2"] = "Move T1 to T2"
-                move_bring[f"{action} T"] = "Move T to S"
-
         all_actions = {
-            **simple_actions,
-            **move_bring,
-            "swap T1 with T2": "Swap T1 with T2",
-            "swap with T": "Swap S with T",
-            "wrap": '"round" wrap T',
-            "format * at T": "Reformat T as *",
+            **all_actions,
+            "{0} T1 to T2".format(keys["bring"]): "Replace T2 with T1",
+            "{0} T".format(keys["bring"]): "Replace S with T",
+            "{0} T1 to T2".format(keys["move"]): "Move T1 to T2",
+            "{0} T".format(keys["move"]): "Move T to S",
+            "{0} T1 to T2".format(keys["swap"]): "Swap T1 with T2",
+            "{0} T".format(keys["swap"]): "Swap S with T",
+            "{0} * at T".format(keys["reformat"]): "Reformat T as *",
         }
 
         actions_limit = round(len(all_actions) / 2)
@@ -134,24 +129,21 @@ def draw(self, canvas):
         self.draw_items(canvas, actions_2)
         self.next_column(canvas)
 
+        all_scopes = get_list("scope_type")
+        scopes_limit = round(len(all_scopes) - 3)
+        scopes_1 = slice_dict(all_scopes, 0, scopes_limit)
+        scopes_2 = slice_dict(all_scopes, scopes_limit)
+
         self.draw_header(canvas, "Scopes")
-        self.draw_items(
-            canvas,
-            get_list(
-                "scope_type",
-                {
-                    "arg": "Argument",
-                    "funk": "Function",
-                    "state": "Statement",
-                    "map": "Map / Dict",
-                    "pair": "Key-val pair",
-                },
-            ),
-        )
+        self.draw_items(canvas, scopes_1)
 
         self.next_column(canvas)
 
         self.draw_header(canvas, "More scopes")
+        self.draw_items(canvas, scopes_2)
+
+        self.next_row()
+        self.draw_header(canvas, "Selection types")
         self.draw_items(canvas, get_list("selection_type"))
 
         self.next_row()
@@ -346,12 +338,16 @@ def cursorless_open_instructions():
 
 
 def get_list(name, descriptions={}):
-    items = registry.lists[f"user.cursorless_{name}"][0].copy()
+    items = get_raw_list(f"user.cursorless_{name}")
     if isinstance(items, dict):
         make_dict_readable(items, descriptions)
     return items
 
 
+def get_raw_list(name):
+    return registry.lists[name][0].copy()
+
+
 def get_y(canvas):
     return canvas.y + outer_padding
 
@@ -360,7 +356,7 @@ def draw_text(canvas, text, x, y):
     canvas.draw_text(text, x, y + text_size + padding / 2)
 
 
-def make_dict_readable(dict, descriptions):
+def make_dict_readable(dict, descriptions={}):
     for k in dict:
         desc = dict[k]
         if desc in descriptions:
@@ -401,3 +397,13 @@ def is_in_rect(canvas, mouse_pos, rect):
 def slice_dict(dict: dict, start: int, end: int = None):
     keys = sorted(dict)[start:end]
     return {key: dict[key] for key in keys}
+
+
+def dict_remove_values(dict: dict, *values: list):
+    keys = {}
+    for key, value in dict.copy().items():
+        if value in values:
+            del dict[key]
+            keys[value] = key
+    assert len(values) == len(keys)
+    return keys

src/compound_targets.py

@@ -4,10 +4,6 @@
 mod = Module()
 ctx = Context()
 
-ctx.matches = r"""
-tag: user.cursorless
-"""
-
 range_specifier = {
     "past",
     "until",