Cleanup

Author: pokey

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

@@ -4,6 +4,8 @@
 
 from talon import app
 
+from .command import CursorlessCommand
+
 SPOKEN_FORMS_OUTPUT_PATH = Path.home() / ".cursorless" / "spokenForms.json"
 
 
@@ -31,7 +33,11 @@ def init(self):
     def write(self, spoken_forms: list[SpokenFormEntry]):
         with open(SPOKEN_FORMS_OUTPUT_PATH, "w") as out:
             try:
-                out.write(json.dumps({"version": 0, "entries": spoken_forms}))
+                out.write(
+                    json.dumps(
+                        {"version": CursorlessCommand.version, "entries": spoken_forms}
+                    )
+                )
             except Exception:
                 error_message = (
                     f"Error writing spoken form json {SPOKEN_FORMS_OUTPUT_PATH}"

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

@@ -6,12 +6,7 @@ import {
 } from "@cursorless/common";
 import { homedir } from "os";
 import * as path from "path";
-import {
-  CustomRegexSpokenFormEntry,
-  PairedDelimiterSpokenFormEntry,
-  SimpleScopeTypeTypeSpokenFormEntry,
-  getSpokenFormEntries,
-} from "./scopeProviders/getSpokenFormEntries";
+import { getSpokenFormEntries } from "./scopeProviders/getSpokenFormEntries";
 import { SpokenFormMap } from "./SpokenFormMap";
 import { defaultSpokenFormMap } from "./DefaultSpokenFormMap";
 
@@ -21,6 +16,12 @@ export const spokenFormsPath = path.join(
   "spokenForms.json",
 );
 
+const ENTRY_TYPES = [
+  "simpleScopeTypeType",
+  "customRegex",
+  "pairedDelimiter",
+] as const;
+
 /**
  * Maintains a list of all scope types and notifies listeners when it changes.
  */
@@ -66,36 +67,22 @@ export class CustomSpokenForms implements SpokenFormMap {
   onDidChangeCustomSpokenForms = this.notifier.registerListener;
 
   private async updateSpokenFormMaps(): Promise<void> {
-    console.log("updateSpokenFormMaps before getSpokenFormEntries");
     const entries = await getSpokenFormEntries();
-    console.log("updateSpokenFormMaps after getSpokenFormEntries");
 
-    this.simpleScopeTypeType = Object.fromEntries(
-      entries
-        .filter(
-          (entry): entry is SimpleScopeTypeTypeSpokenFormEntry =>
-            entry.type === "simpleScopeTypeType",
-        )
-        .map(({ id, spokenForms }) => [id, spokenForms] as const),
-    );
-    this.customRegex = Object.fromEntries(
-      entries
-        .filter(
-          (entry): entry is CustomRegexSpokenFormEntry =>
-            entry.type === "customRegex",
-        )
-        .map(({ id, spokenForms }) => [id, spokenForms] as const),
-    );
-    this.pairedDelimiter = Object.fromEntries(
-      entries
-        .filter(
-          (entry): entry is PairedDelimiterSpokenFormEntry =>
-            entry.type === "pairedDelimiter",
-        )
-        .map(({ id, spokenForms }) => [id, spokenForms] as const),
-    );
+    for (const entryType of ENTRY_TYPES) {
+      // TODO: Handle case where we've added a new scope type but they haven't yet
+      // updated their talon files. In that case we want to indicate in tree view
+      // that the scope type exists but they need to update their talon files to
+      // be able to speak it. We could just detect that there's no entry for it in
+      // the spoken forms file, but that feels a bit brittle.
+      // FIXME: How to avoid the type assertion?
+      this[entryType] = Object.fromEntries(
+        entries
+          .filter((entry) => entry.type === entryType)
+          .map(({ id, spokenForms }) => [id, spokenForms]),
+      ) as any;
+    }
 
-    console.log("updateSpokenFormMaps at end");
     this.isInitialized_ = true;
     this.notifier.notifyListeners();
   }

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

@@ -25,15 +25,21 @@ export class CustomSpokenFormGenerator {
     );
   }
 
-  onDidChangeCustomSpokenForms = (listener: Listener<[]>) =>
-    this.customSpokenForms.onDidChangeCustomSpokenForms(listener);
+  onDidChangeCustomSpokenForms(listener: Listener<[]>) {
+    return this.customSpokenForms.onDidChangeCustomSpokenForms(listener);
+  }
 
-  commandToSpokenForm = (command: CommandComplete) =>
-    this.spokenFormGenerator.command(command);
+  commandToSpokenForm(command: CommandComplete) {
+    return this.spokenFormGenerator.command(command);
+  }
 
-  scopeTypeToSpokenForm = (scopeType: ScopeType) =>
-    this.spokenFormGenerator.scopeType(scopeType);
+  scopeTypeToSpokenForm(scopeType: ScopeType) {
+    return this.spokenFormGenerator.scopeType(scopeType);
+  }
+
+  getCustomRegexScopeTypes() {
+    return this.customSpokenForms.getCustomRegexScopeTypes();
+  }
 
-  getCustomRegexScopeTypes = () =>
-    this.customSpokenForms.getCustomRegexScopeTypes();
+  dispose = this.disposer.dispose;
 }

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

@@ -1,4 +1,4 @@
-import { SimpleScopeTypeType } from "@cursorless/common";
+import { LATEST_VERSION, SimpleScopeTypeType } from "@cursorless/common";
 import { readFile } from "fs/promises";
 import { spokenFormsPath } from "./ScopeInfoProvider";
 import { SpeakableSurroundingPairName } from "../SpokenFormMap";
@@ -28,7 +28,16 @@ type SpokenFormEntry =
 
 export async function getSpokenFormEntries(): Promise<SpokenFormEntry[]> {
   try {
-    return JSON.parse(await readFile(spokenFormsPath, "utf-8")).entries;
+    const payload = JSON.parse(await readFile(spokenFormsPath, "utf-8"));
+
+    if (payload.version !== LATEST_VERSION) {
+      // In the future, we'll need to handle migrations. Not sure exactly how yet.
+      throw new Error(
+        `Invalid spoken forms version. Expected ${LATEST_VERSION} but got ${payload.version}`,
+      );
+    }
+
+    return payload.entries;
   } catch (err) {
     console.error(`Error getting spoken forms`);
     console.error(err);