Revisualize on custom regex change

Author: pokey

packages/common/src/types/ScopeProvider.ts

@@ -94,6 +94,18 @@ export interface ScopeProvider {
    * @returns A {@link Disposable} which will stop the callback from running
    */
   onDidChangeScopeInfo(callback: ScopeTypeInfoEventCallback): Disposable;
+
+  /**
+   * Determine the level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}, as determined by its language id.
+   * @param editor The editor to check
+   * @param scopeType The scope type to check
+   * @returns The level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}
+   */
+  getScopeInfo: (
+    scopeType: ScopeType,
+  ) => ScopeTypeInfo;
 }
 
 interface ScopeRangeConfigBase {

packages/common/src/util/Disposer.ts

@@ -9,6 +9,10 @@ import { Disposable } from "../ide/types/ide.types";
 export class Disposer implements Disposable {
   private disposables: Disposable[] = [];
 
+  constructor(...disposables: Disposable[]) {
+    this.push(...disposables)
+  }
+
   public push(...disposables: Disposable[]) {
     this.disposables.push(...disposables);
   }

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -151,6 +151,7 @@ function createScopeProvider(
     getScopeSupport: supportChecker.getScopeSupport,
     getIterationScopeSupport: supportChecker.getIterationScopeSupport,
     onDidChangeScopeSupport: supportWatcher.onDidChangeScopeSupport,
+    getScopeInfo: infoProvider.getScopeTypeInfo,
     onDidChangeScopeInfo: infoProvider.onDidChangeScopeInfo,
   };
 }

packages/cursorless-engine/src/scopeProviders/ScopeInfoProvider.ts

@@ -32,6 +32,7 @@ export class ScopeInfoProvider {
     );
 
     this.onDidChangeScopeInfo = this.onDidChangeScopeInfo.bind(this);
+    this.getScopeTypeInfo = this.getScopeTypeInfo.bind(this);
     this.updateScopeTypeInfos();
   }
 

packages/cursorless-engine/src/scopeProviders/ScopeSupportWatcher.ts

@@ -39,7 +39,7 @@ export class ScopeSupportWatcher {
       // dirty-state changes.
       ide().onDidChangeTextDocument(this.debouncer.run),
       languageDefinitions.onDidChangeDefinition(this.debouncer.run),
-      this.scopeInfoProvider.onDidChangeScopeInfo(this.debouncer.run),
+      this.scopeInfoProvider.onDidChangeScopeInfo(() => this.onChange()),
       this.debouncer,
     );
 

packages/cursorless-vscode/src/ScopeVisualizerCommandApi.ts

@@ -1,7 +1,7 @@
 import { Disposable, ScopeType } from "@cursorless/common";
 
 export type VisualizerScopeTypeListener = (
-  scopeType: ScopeType | undefined,
+  scopeType: ScopeType | undefined, visualizationType: VisualizationType | undefined,
 ) => void;
 
 export interface ScopeVisualizer {

packages/cursorless-vscode/src/extension.ts

@@ -35,14 +35,15 @@ import {
 import { KeyboardCommands } from "./keyboard/KeyboardCommands";
 import { registerCommands } from "./registerCommands";
 import { ReleaseNotes } from "./ReleaseNotes";
+import { ScopeTreeProvider } from "./ScopeTreeProvider";
 import {
   ScopeVisualizer,
+  VisualizerScopeTypeListener as ScopeVisualizerListener,
   VisualizationType,
-  VisualizerScopeTypeListener,
 } from "./ScopeVisualizerCommandApi";
 import { StatusBarItem } from "./StatusBarItem";
 import { vscodeApi } from "./vscodeApi";
-import { ScopeTreeProvider } from "./ScopeTreeProvider";
+import { revisualizeOnCustomRegexChange } from "./revisualizeOnCustomRegexChange";
 
 /**
  * Extension entrypoint called by VSCode on Cursorless startup.
@@ -97,6 +98,9 @@ export async function activate(
   const statusBarItem = StatusBarItem.create("cursorless.showQuickPick");
   const keyboardCommands = KeyboardCommands.create(context, statusBarItem);
   const scopeVisualizer = createScopeVisualizer(normalizedIde, scopeProvider);
+  context.subscriptions.push(
+    revisualizeOnCustomRegexChange(scopeVisualizer, scopeProvider),
+  );
   ScopeTreeProvider.create(
     vscodeApi,
     context,
@@ -178,7 +182,7 @@ function createScopeVisualizer(
   let scopeVisualizer: VscodeScopeVisualizer | undefined;
   let currentScopeType: ScopeType | undefined;
 
-  const listeners: VisualizerScopeTypeListener[] = [];
+  const listeners: ScopeVisualizerListener[] = [];
 
   return {
     start(scopeType: ScopeType, visualizationType: VisualizationType) {
@@ -191,21 +195,21 @@ function createScopeVisualizer(
       );
       scopeVisualizer.start();
       currentScopeType = scopeType;
-      listeners.forEach((listener) => listener(scopeType));
+      listeners.forEach((listener) => listener(scopeType, visualizationType));
     },
 
     stop() {
       scopeVisualizer?.dispose();
       scopeVisualizer = undefined;
       currentScopeType = undefined;
-      listeners.forEach((listener) => listener(undefined));
+      listeners.forEach((listener) => listener(undefined, undefined));
     },
 
     get scopeType() {
       return currentScopeType;
     },
 
-    onDidChangeScopeType(listener: VisualizerScopeTypeListener): Disposable {
+    onDidChangeScopeType(listener: ScopeVisualizerListener): Disposable {
       listeners.push(listener);
 
       return {

packages/cursorless-vscode/src/revisualizeOnCustomRegexChange.ts

@@ -0,0 +1,53 @@
+import {
+  Disposable,
+  Disposer, ScopeProvider, ScopeTypeInfo
+} from "@cursorless/common";
+import { ScopeVisualizer, VisualizationType } from "./ScopeVisualizerCommandApi";
+import { isEqual } from "lodash";
+
+/**
+ * Attempts to ensure that the scope visualizer is still visualizing the same
+ * scope type after the user changes one of their custom regexes. Because custom
+ * regexes don't have a unique identifier, we have to do some guesswork to
+ * figure out which custom regex the user changed. This function look for a
+ * custom regex with the same spoken form as the one that was changed, and if it
+ * finds one, it starts visualizing that one instead.
+ *
+ * @param scopeVisualizer The scope visualizer to listen to
+ * @param scopeProvider Provides scope information
+ * @returns A {@link Disposable} which will stop the callback from running
+ */
+export function revisualizeOnCustomRegexChange(
+  scopeVisualizer: ScopeVisualizer,
+  scopeProvider: ScopeProvider
+): Disposable {
+  let currentRegexScopeInfo: ScopeTypeInfo | undefined;
+  let currentVisualizationType: VisualizationType | undefined;
+
+  return new Disposer(
+    scopeVisualizer.onDidChangeScopeType((scopeType, visualizationType) => {
+      currentRegexScopeInfo =
+        scopeType?.type === "customRegex"
+          ? scopeProvider.getScopeInfo(scopeType)
+          : undefined;
+      currentVisualizationType = visualizationType;
+    }),
+
+    scopeProvider.onDidChangeScopeInfo((scopeInfos) => {
+      if (currentRegexScopeInfo != null &&
+        !scopeInfos.some((scopeInfo) => isEqual(scopeInfo.scopeType, currentRegexScopeInfo!.scopeType)
+        )) {
+        const replacement = scopeInfos.find(
+          (scopeInfo) => scopeInfo.scopeType.type === "customRegex" &&
+            isEqual(scopeInfo.spokenForm, currentRegexScopeInfo!.spokenForm)
+        );
+        if (replacement != null) {
+          scopeVisualizer.start(
+            replacement.scopeType,
+            currentVisualizationType!
+          );
+        }
+      }
+    })
+  );
+}