Initial working version

Author: pokey

Diff for: cursorless-talon/src/csv_overrides.py

@@ -1,8 +1,9 @@
 import csv
 from collections.abc import Container
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Callable, Optional, TypedDict
 
 from talon import Context, Module, actions, app, fs
 
@@ -35,13 +36,21 @@
 """
 
 
+# Maps from Talon list name to a map from spoken form to value
 ListToSpokenForms = dict[str, dict[str, str]]
 
 
+@dataclass
+class SpokenFormEntry:
+    list_name: str
+    id: str
+    spoken_forms: list[str]
+
+
 def init_csv_and_watch_changes(
     filename: str,
     default_values: ListToSpokenForms,
-    handle_new_values: Optional[Callable[[ListToSpokenForms], None]] = None,
+    handle_new_values: Optional[Callable[[list[SpokenFormEntry]], None]] = None,
     extra_ignored_values: Optional[list[str]] = None,
     allow_unknown_values: bool = False,
     default_list_name: Optional[str] = None,
@@ -69,7 +78,7 @@ def init_csv_and_watch_changes(
             `cursorles-settings` dir
         default_values (ListToSpokenForms): The default values for the lists to
             be customized in the given csv
-        handle_new_values (Optional[Callable[[ListToSpokenForms], None]]): A
+        handle_new_values (Optional[Callable[[list[SpokenFormEntry]], None]]): A
             callback to be called when the lists are updated
         extra_ignored_values (Optional[list[str]]): Don't throw an exception if
             any of these appear as values; just ignore them and don't add them
@@ -185,18 +194,18 @@ def create_default_vocabulary_dicts(
 
 
 def update_dicts(
-    default_values: dict[str, dict],
-    current_values: dict,
+    default_values: ListToSpokenForms,
+    current_values: dict[str, str],
     extra_ignored_values: list[str],
     allow_unknown_values: bool,
     default_list_name: Optional[str],
     pluralize_lists: list[str],
-    handle_new_values: Optional[Callable[[ListToSpokenForms], None]],
+    handle_new_values: Optional[Callable[[list[SpokenFormEntry]], None]],
 ):
     # Create map with all default values
-    results_map = {}
-    for list_name, dict in default_values.items():
-        for key, value in dict.items():
+    results_map: dict[str, ResultsListEntry] = {}
+    for list_name, obj in default_values.items():
+        for key, value in obj.items():
             results_map[value] = {"key": key, "value": value, "list": list_name}
 
     # Update result with current values
@@ -206,7 +215,7 @@ def update_dicts(
         except KeyError:
             if value in extra_ignored_values:
                 pass
-            elif allow_unknown_values:
+            elif allow_unknown_values and default_list_name is not None:
                 results_map[value] = {
                     "key": key,
                     "value": value,
@@ -217,9 +226,35 @@ def update_dicts(
 
     # Convert result map back to result list
     results = {res["list"]: {} for res in results_map.values()}
-    for obj in results_map.values():
+    values: list[SpokenFormEntry] = []
+    for list_name, id, spoken_forms in generate_spoken_forms(
+        list(results_map.values())
+    ):
+        for spoken_form in spoken_forms:
+            results[list_name][spoken_form] = id
+        values.append(
+            SpokenFormEntry(list_name=list_name, id=id, spoken_forms=spoken_forms)
+        )
+
+    # Assign result to talon context list
+    assign_lists_to_context(ctx, results, pluralize_lists)
+
+    if handle_new_values is not None:
+        handle_new_values(values)
+
+
+class ResultsListEntry(TypedDict):
+    key: str
+    value: str
+    list: str
+
+
+def generate_spoken_forms(results_list: list[ResultsListEntry]):
+    for obj in results_list:
         value = obj["value"]
         key = obj["key"]
+
+        spoken = []
         if not is_removed(key):
             for k in key.split("|"):
                 if value == "pasteFromClipboard" and k.endswith(" to"):
@@ -230,13 +265,13 @@ def update_dicts(
                     # cursorless before this change would have "paste to" as
                     # their spoken form and so would need to say "paste to to".
                     k = k[:-3]
-                results[obj["list"]][k.strip()] = value
+                spoken.append(k.strip())
 
-    # Assign result to talon context list
-    assign_lists_to_context(ctx, results, pluralize_lists)
-
-    if handle_new_values is not None:
-        handle_new_values(results)
+        yield (
+            obj["list"],
+            value,
+            spoken,
+        )
 
 
 def assign_lists_to_context(

Diff for: cursorless-talon/src/spoken_forms.py

@@ -1,11 +1,15 @@
 import json
-from itertools import groupby
 from pathlib import Path
 from typing import Callable, Concatenate, ParamSpec, TypeVar
 
 from talon import app, fs
 
-from .csv_overrides import SPOKEN_FORM_HEADER, init_csv_and_watch_changes
+from .csv_overrides import (
+    SPOKEN_FORM_HEADER,
+    ListToSpokenForms,
+    SpokenFormEntry,
+    init_csv_and_watch_changes,
+)
 from .marks.decorated_mark import init_hats
 from .spoken_forms_output import SpokenFormsOutput
 
@@ -16,15 +20,13 @@
 P = ParamSpec("P")
 R = TypeVar("R")
 
-# Maps from Talon list name to a map from spoken form to value
-ListToSpokenForms = dict[str, dict[str, str]]
-
 
 def auto_construct_defaults(
     spoken_forms: dict[str, ListToSpokenForms],
-    handle_new_values: Callable[[ListToSpokenForms], None],
+    handle_new_values: Callable[[list[SpokenFormEntry]], None],
     f: Callable[
-        Concatenate[str, ListToSpokenForms, Callable[[ListToSpokenForms], None], P], R
+        Concatenate[str, ListToSpokenForms, Callable[[list[SpokenFormEntry]], None], P],
+        R,
     ],
 ):
     """
@@ -74,27 +76,25 @@ def update():
         spoken_forms = json.load(file)
 
     initialized = False
-    custom_spoken_forms: ListToSpokenForms = {}
+    custom_spoken_forms: list[SpokenFormEntry] = []
     spoken_forms_output = SpokenFormsOutput()
     spoken_forms_output.init()
 
     def update_spoken_forms_output():
         spoken_forms_output.write(
             [
                 {
-                    "type": entry_type,
-                    "id": value,
-                    "spokenForms": [spoken_form[0] for spoken_form in spoken_forms],
+                    "type": LIST_TO_TYPE_MAP[entry.list_name],
+                    "id": entry.id,
+                    "spokenForms": entry.spoken_forms,
                 }
-                for list_name, entry_type in LIST_TO_TYPE_MAP.items()
-                for value, spoken_forms in groupby(
-                    custom_spoken_forms[list_name].items(), lambda item: item[1]
-                )
+                for entry in custom_spoken_forms
+                if entry.list_name in LIST_TO_TYPE_MAP
             ]
         )
 
-    def handle_new_values(values: ListToSpokenForms):
-        custom_spoken_forms.update(values)
+    def handle_new_values(values: list[SpokenFormEntry]):
+        custom_spoken_forms.extend(values)
         if initialized:
             # On first run, we just do one update at the end, so we suppress
             # writing until we get there

Diff for: packages/cursorless-engine/src/cursorlessEngine.ts

@@ -6,14 +6,14 @@ import {
   IDE,
 } from "@cursorless/common";
 import { StoredTargetMap, TestCaseRecorder, TreeSitter } from ".";
-import { CustomSpokenForms } from "./CustomSpokenForms";
 import { CursorlessEngine } from "./api/CursorlessEngineApi";
 import { ScopeProvider } from "./api/ScopeProvider";
 import { Debug } from "./core/Debug";
 import { HatTokenMapImpl } from "./core/HatTokenMapImpl";
 import { Snippets } from "./core/Snippets";
 import { ensureCommandShape } from "./core/commandVersionUpgrades/ensureCommandShape";
 import { RangeUpdater } from "./core/updateSelections/RangeUpdater";
+import { CustomSpokenFormGenerator } from "./generateSpokenForm/CustomSpokenFormGenerator";
 import { LanguageDefinitions } from "./languages/LanguageDefinitions";
 import { ModifierStageFactoryImpl } from "./processTargets/ModifierStageFactoryImpl";
 import { ScopeHandlerFactoryImpl } from "./processTargets/modifiers/scopeHandlers";
@@ -25,7 +25,6 @@ import { ScopeRangeWatcher } from "./scopeProviders/ScopeRangeWatcher";
 import { ScopeSupportChecker } from "./scopeProviders/ScopeSupportChecker";
 import { ScopeSupportWatcher } from "./scopeProviders/ScopeSupportWatcher";
 import { injectIde } from "./singletons/ide.singleton";
-import { SpokenFormGenerator } from "./generateSpokenForm";
 
 export function createCursorlessEngine(
   treeSitter: TreeSitter,
@@ -57,7 +56,7 @@ export function createCursorlessEngine(
 
   const languageDefinitions = new LanguageDefinitions(fileSystem, treeSitter);
 
-  const customSpokenForms = new CustomSpokenForms(fileSystem);
+  const customSpokenFormGenerator = new CustomSpokenFormGenerator(fileSystem);
 
   ide.disposeOnExit(rangeUpdater, languageDefinitions, hatTokenMap, debug);
 
@@ -94,7 +93,7 @@ export function createCursorlessEngine(
     scopeProvider: createScopeProvider(
       languageDefinitions,
       storedTargets,
-      customSpokenForms,
+      customSpokenFormGenerator,
     ),
     testCaseRecorder,
     storedTargets,
@@ -109,7 +108,7 @@ export function createCursorlessEngine(
 function createScopeProvider(
   languageDefinitions: LanguageDefinitions,
   storedTargets: StoredTargetMap,
-  customSpokenForms: CustomSpokenForms,
+  customSpokenFormGenerator: CustomSpokenFormGenerator,
 ): ScopeProvider {
   const scopeHandlerFactory = new ScopeHandlerFactoryImpl(languageDefinitions);
 
@@ -127,10 +126,7 @@ function createScopeProvider(
     rangeProvider,
   );
   const supportChecker = new ScopeSupportChecker(scopeHandlerFactory);
-  const infoProvider = new ScopeInfoProvider(
-    customSpokenForms,
-    new SpokenFormGenerator(customSpokenForms),
-  );
+  const infoProvider = new ScopeInfoProvider(customSpokenFormGenerator);
   const supportWatcher = new ScopeSupportWatcher(
     languageDefinitions,
     supportChecker,

Diff for: packages/cursorless-engine/src/generateSpokenForm/CustomSpokenFormGenerator.ts

@@ -0,0 +1,39 @@
+import {
+  CommandComplete,
+  Disposer,
+  FileSystem,
+  Listener,
+  ScopeType,
+} from "@cursorless/common";
+import { SpokenFormGenerator } from ".";
+import { CustomSpokenForms } from "../CustomSpokenForms";
+
+export class CustomSpokenFormGenerator {
+  private customSpokenForms: CustomSpokenForms;
+  private spokenFormGenerator: SpokenFormGenerator;
+  private disposer = new Disposer();
+
+  constructor(fileSystem: FileSystem) {
+    this.customSpokenForms = new CustomSpokenForms(fileSystem);
+    this.spokenFormGenerator = new SpokenFormGenerator(this.customSpokenForms);
+    this.disposer.push(
+      this.customSpokenForms.onDidChangeCustomSpokenForms(() => {
+        this.spokenFormGenerator = new SpokenFormGenerator(
+          this.customSpokenForms,
+        );
+      }),
+    );
+  }
+
+  onDidChangeCustomSpokenForms = (listener: Listener<[]>) =>
+    this.customSpokenForms.onDidChangeCustomSpokenForms(listener);
+
+  commandToSpokenForm = (command: CommandComplete) =>
+    this.spokenFormGenerator.command(command);
+
+  scopeTypeToSpokenForm = (scopeType: ScopeType) =>
+    this.spokenFormGenerator.scopeType(scopeType);
+
+  getCustomRegexScopeTypes = () =>
+    this.customSpokenForms.getCustomRegexScopeTypes();
+}

Diff for: packages/cursorless-engine/src/scopeProviders/ScopeInfoProvider.ts

@@ -10,9 +10,8 @@ import { pull } from "lodash";
 import { homedir } from "os";
 import * as path from "path";
 import { ScopeTypeInfo, ScopeTypeInfoEventCallback } from "..";
-import { CustomSpokenForms } from "../CustomSpokenForms";
 
-import { SpokenFormGenerator } from "../generateSpokenForm";
+import { CustomSpokenFormGenerator } from "../generateSpokenForm/CustomSpokenFormGenerator";
 import { scopeTypeToString } from "./scopeTypeToString";
 
 export const spokenFormsPath = path.join(
@@ -29,12 +28,11 @@ export class ScopeInfoProvider {
   private listeners: ScopeTypeInfoEventCallback[] = [];
   private scopeInfos!: ScopeTypeInfo[];
 
-  constructor(
-    private customSpokenForms: CustomSpokenForms,
-    private spokenFormGenerator: SpokenFormGenerator,
-  ) {
+  constructor(private customSpokenFormGenerator: CustomSpokenFormGenerator) {
     this.disposer.push(
-      customSpokenForms.onDidChangeCustomSpokenForms(() => this.onChange()),
+      customSpokenFormGenerator.onDidChangeCustomSpokenForms(() =>
+        this.onChange(),
+      ),
     );
 
     this.onDidChangeScopeInfo = this.onDidChangeScopeInfo.bind(this);
@@ -87,7 +85,7 @@ export class ScopeInfoProvider {
         }),
       ),
 
-      ...this.customSpokenForms.getCustomRegexScopeTypes(),
+      ...this.customSpokenFormGenerator.getCustomRegexScopeTypes(),
     ];
 
     this.scopeInfos = scopeTypes.map((scopeType) =>
@@ -102,7 +100,8 @@ export class ScopeInfoProvider {
   getScopeTypeInfo(scopeType: ScopeType): ScopeTypeInfo {
     return {
       scopeType,
-      spokenForm: this.spokenFormGenerator.scopeType(scopeType),
+      spokenForm:
+        this.customSpokenFormGenerator.scopeTypeToSpokenForm(scopeType),
       humanReadableName: scopeTypeToString(scopeType),
       isLanguageSpecific: isLanguageSpecific(scopeType),
     };