Reimplement cheatsheet using html (#619)

* Cheatsheet nx html generation

* HTML cheatsheet talon side

* HTML cheatsheet VSCode extension-side

* Tweak deploy

* identifier => id

* Tweaks from PR feedback

* Rename dir

* update defaults.json

* Remove nx-welcome.tsx

Author: pokey

src/cheatsheet/cheat_sheet.py

@@ -1,5 +1,4 @@
 import math
-import webbrowser
 from typing import Optional
 
 from talon import Module, actions, cron, skia, ui
@@ -302,10 +301,6 @@ def cursorless_cheat_sheet_toggle():
             cheat_sheet = CheatSheet()
             actions.mode.enable("user.cursorless_cheat_sheet")
 
-    def cursorless_open_instructions():
-        """Open web page with cursorless instructions"""
-        webbrowser.open(instructions_url)
-
 
 def get_y(canvas):
     return canvas.y + outer_padding

src/cheatsheet_html/cheat_sheet.py

@@ -0,0 +1,89 @@
+import tempfile
+import webbrowser
+from pathlib import Path
+
+from talon import Module, actions
+
+from .get_list import get_list, get_lists
+from .sections.actions import get_actions
+from .sections.compound_targets import get_compound_targets
+from .sections.scopes import get_scopes
+
+mod = Module()
+
+cheatsheet_out_dir = Path(tempfile.mkdtemp())
+instructions_url = "https://www.cursorless.org/docs/"
+
+
+@mod.action_class
+class Actions:
+    def cursorless_cheat_sheet_show_html():
+        """Show new cursorless html cheat sheet"""
+        cheatsheet_out_path = cheatsheet_out_dir / "cheatsheet.html"
+        actions.user.vscode_with_plugin_and_wait(
+            "cursorless.showCheatsheet",
+            {
+                "version": 0,
+                "spokenFormInfo": actions.user.cursorless_cheat_sheet_get_json(),
+                "outputPath": str(cheatsheet_out_path),
+            },
+        )
+        webbrowser.open(cheatsheet_out_path.as_uri())
+
+    def cursorless_cheat_sheet_get_json():
+        """Get cursorless cheat sheet json"""
+        return {
+            "sections": [
+                {
+                    "name": "Actions",
+                    "id": "actions",
+                    "items": get_actions(),
+                },
+                {
+                    "name": "Scopes",
+                    "id": "scopes",
+                    "items": get_scopes(),
+                },
+                {
+                    "name": "Paired delimiters",
+                    "id": "pairedDelimiters",
+                    "items": get_lists(
+                        [
+                            "wrapper_only_paired_delimiter",
+                            "wrapper_selectable_paired_delimiter",
+                            "selectable_only_paired_delimiter",
+                        ],
+                        "pairedDelimiter",
+                    ),
+                },
+                {
+                    "name": "Special marks",
+                    "id": "specialMarks",
+                    "items": get_list("special_mark", "mark"),
+                },
+                {
+                    "name": "Positions",
+                    "id": "positions",
+                    "items": get_list("position", "position"),
+                },
+                {
+                    "name": "Compound targets",
+                    "id": "compoundTargets",
+                    "items": get_compound_targets(),
+                },
+                {
+                    "name": "Colors",
+                    "id": "colors",
+                    "items": get_list("hat_color", "hatColor"),
+                },
+                {
+                    "name": "Shapes",
+                    "id": "shapes",
+                    "items": get_list("hat_shape", "hatShape"),
+                },
+            ]
+        }
+
+    def cursorless_open_instructions():
+        """Open web page with cursorless instructions"""
+        webbrowser.open(instructions_url)

src/cheatsheet_html/get_list.py

@@ -0,0 +1,58 @@
+import re
+
+from talon import registry
+
+from ..conventions import get_cursorless_list_name
+
+
+def get_list(name, type, descriptions=None):
+    if descriptions is None:
+        descriptions = {}
+
+    items = get_raw_list(name)
+    item_dict = items if isinstance(items, dict) else {item: item for item in items}
+
+    return make_dict_readable(type, item_dict, descriptions)
+
+
+def get_lists(names: list[str], type: str, descriptions=None):
+
+    return [item for name in names for item in get_list(name, type, descriptions)]
+
+
+def get_raw_list(name):
+    cursorless_list_name = get_cursorless_list_name(name)
+    return registry.lists[cursorless_list_name][0].copy()
+
+
+def make_dict_readable(type: str, dict, descriptions=None):
+    if descriptions is None:
+        descriptions = {}
+
+    return [
+        {
+            "id": value,
+            "type": type,
+            "variations": [
+                {
+                    "spokenForm": key,
+                    "description": descriptions.get(value, make_readable(value)),
+                }
+            ],
+        }
+        for key, value in dict.items()
+    ]
+
+
+def make_readable(text):
+    text = text.replace(".", " ")
+    return de_camel(text).lower().capitalize()
+
+
+def de_camel(text: str) -> str:
+    """Replacing camelCase boundaries with blank space"""
+    return re.sub(
+        r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-zA-Z])(?=[0-9])|(?<=[0-9])(?=[a-zA-Z])",
+        " ",
+        text,
+    )

src/cheatsheet_html/sections/actions.py

@@ -0,0 +1,114 @@
+from ...actions.actions import ACTION_LIST_NAMES
+from ..get_list import get_raw_list, make_dict_readable
+
+
+def get_actions():
+    all_actions = {}
+    for name in ACTION_LIST_NAMES:
+        all_actions.update(get_raw_list(name))
+
+    multiple_target_action_names = [
+        "replaceWithTarget",
+        "moveToTarget",
+        "swapTargets",
+        "applyFormatter",
+        "wrapWithPairedDelimiter",
+        "rewrap",
+    ]
+    simple_actions = {
+        f"{key} <T>": value
+        for key, value in all_actions.items()
+        if value not in multiple_target_action_names
+    }
+    complex_actions = {
+        value: key
+        for key, value in all_actions.items()
+        if value in multiple_target_action_names
+    }
+
+    swap_connective = list(get_raw_list("swap_connective").keys())[0]
+    source_destination_connective = list(
+        get_raw_list("source_destination_connective").keys()
+    )[0]
+
+    return [
+        *make_dict_readable(
+            "action",
+            simple_actions,
+            {
+                "callAsFunction": "Call T on S",
+            },
+        ),
+        {
+            "id": "replaceWithTarget",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"{complex_actions['replaceWithTarget']} <T1> {source_destination_connective} <T2>",
+                    "description": "Replace T2 with T1",
+                },
+                {
+                    "spokenForm": f"{complex_actions['replaceWithTarget']} <T>",
+                    "description": "Replace S with T",
+                },
+            ],
+        },
+        {
+            "id": "moveToTarget",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"{complex_actions['moveToTarget']} <T1> {source_destination_connective} <T2>",
+                    "description": "Move T1 to T2",
+                },
+                {
+                    "spokenForm": f"{complex_actions['moveToTarget']} <T>",
+                    "description": "Move T to S",
+                },
+            ],
+        },
+        {
+            "id": "swapTargets",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"{complex_actions['swapTargets']} <T1> {swap_connective} <T2>",
+                    "description": "Swap T1 with T2",
+                },
+                {
+                    "spokenForm": f"{complex_actions['swapTargets']} {swap_connective} <T>",
+                    "description": "Swap S with T",
+                },
+            ],
+        },
+        {
+            "id": "applyFormatter",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"{complex_actions['applyFormatter']} <F> at <T>",
+                    "description": "Reformat T as F",
+                }
+            ],
+        },
+        {
+            "id": "wrapWithPairedDelimiter",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"<P> {complex_actions['wrapWithPairedDelimiter']} <T>",
+                    "description": "Wrap T with P",
+                }
+            ],
+        },
+        {
+            "id": "rewrap",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"<P> {complex_actions['rewrap']} <T>",
+                    "description": "Rewrap T with P",
+                }
+            ],
+        },
+    ]

src/cheatsheet_html/sections/compound_targets.py

@@ -0,0 +1,41 @@
+from ..get_list import get_raw_list
+
+
+def get_compound_targets():
+    include_both_term = next(
+        spoken_form
+        for spoken_form, value in get_raw_list("range_connective").items()
+        if value == "rangeInclusive"
+    )
+    list_connective_term = next(
+        spoken_form
+        for spoken_form, value in get_raw_list("list_connective").items()
+        if value == "listConnective"
+    )
+
+    return [
+        {
+            "id": "listConnective",
+            "type": "compoundTargetConnective",
+            "variations": [
+                {
+                    "spokenForm": f"<T1> {list_connective_term} <T2>",
+                    "description": "T1 and T2",
+                },
+            ],
+        },
+        {
+            "id": "rangeInclusive",
+            "type": "action",
+            "variations": [
+                {
+                    "spokenForm": f"<T1> {include_both_term} <T2>",
+                    "description": "T1 through T2",
+                },
+                {
+                    "spokenForm": f"{include_both_term} <T>",
+                    "description": "S through T",
+                },
+            ],
+        },
+    ]

src/cheatsheet_html/sections/scopes.py

@@ -0,0 +1,9 @@
+from ..get_list import get_lists
+
+
+def get_scopes():
+    return get_lists(
+        ["scope_type", "subtoken_scope_type"],
+        "scopeType",
+        {"argumentOrParameter": "Argument"},
+    )

src/cursorless.talon

@@ -21,3 +21,4 @@ app: vscode
 
 cursorless help:           user.cursorless_cheat_sheet_toggle()
 cursorless instructions:   user.cursorless_open_instructions()
+cursorless reference:   user.cursorless_cheat_sheet_show_html()