Merge branch 'main' into interiorScope

phillco · web-flow · commit 7f03ae60af90 · 2025-01-30T09:59:48.000-08:00
diff --git a/cursorless-talon/src/actions/generate_snippet.py b/cursorless-talon/src/actions/generate_snippet.py
@@ -1,7 +1,7 @@
 import glob
 from pathlib import Path
 
-from talon import Context, Module, actions, settings
+from talon import Context, Module, actions, registry, settings
 
 from ..targets.target_types import CursorlessExplicitTarget
 
@@ -20,6 +20,15 @@ def private_cursorless_migrate_snippets():
         actions.user.private_cursorless_run_rpc_command_no_wait(
             "cursorless.migrateSnippets",
             str(get_directory_path()),
+            {
+                "insertion": registry.lists[
+                    "user.cursorless_insertion_snippet_no_phrase"
+                ][-1],
+                "insertionWithPhrase": registry.lists[
+                    "user.cursorless_insertion_snippet_single_phrase"
+                ][-1],
+                "wrapper": registry.lists["user.cursorless_wrapper_snippet"][-1],
+            },
         )
 
     def private_cursorless_generate_snippet_action(target: CursorlessExplicitTarget):  # pyright: ignore [reportGeneralTypeIssues]
diff --git a/data/fixtures/recorded/fallback/takeThis.yml b/data/fixtures/recorded/fallback/takeThis.yml
@@ -22,5 +22,4 @@ finalState:
       active: {line: 0, character: 0}
 fallback:
   action: setSelection
-  modifiers:
-    - {type: containingTokenIfEmpty}
+  modifiers: []
diff --git a/packages/cursorless-engine/src/core/getCommandFallback.ts b/packages/cursorless-engine/src/core/getCommandFallback.ts
@@ -142,9 +142,11 @@ function getModifiersFromTarget(
       return target.modifiers;
     }
 
-    if (target.mark?.type === "cursor") {
-      return [{ type: "containingTokenIfEmpty" }];
-    }
+    // FIXME: Trying to select a word in the file explorer will create weird behavior.
+    // https://github.com/cursorless-dev/cursorless/issues/2800
+    // if (target.mark?.type === "cursor") {
+    //   return [{ type: "containingTokenIfEmpty" }];
+    // }
   }
   return [];
 }
diff --git a/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/CollectionItemScopeHandler.ts b/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/CollectionItemScopeHandler.ts
@@ -48,15 +48,8 @@ export class CollectionItemScopeHandler extends BaseScopeHandler {
 
       return OneOfScopeHandler.createFromScopeHandlers(
         scopeHandlerFactory,
-        {
-          type: "oneOf",
-          scopeTypes: [
-            languageScopeHandler.scopeType,
-            textualScopeHandler.scopeType,
-          ],
-        },
-        [languageScopeHandler, textualScopeHandler],
         languageId,
+        [languageScopeHandler, textualScopeHandler],
       );
     })();
   }
diff --git a/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/NotebookCellScopeHandler.ts b/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/NotebookCellScopeHandler.ts
@@ -46,15 +46,8 @@ export class NotebookCellScopeHandler extends BaseScopeHandler {
 
       return OneOfScopeHandler.createFromScopeHandlers(
         scopeHandlerFactory,
-        {
-          type: "oneOf",
-          scopeTypes: [
-            languageScopeHandler.scopeType,
-            apiScopeHandler.scopeType,
-          ],
-        },
-        [languageScopeHandler, apiScopeHandler],
         languageId,
+        [languageScopeHandler, apiScopeHandler],
       );
     })();
   }
diff --git a/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/OneOfScopeHandler.ts b/packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/OneOfScopeHandler.ts
@@ -17,6 +17,7 @@ import type {
 
 export class OneOfScopeHandler extends BaseScopeHandler {
   protected isHierarchical = true;
+  public scopeType = undefined;
   private iterationScopeHandler: OneOfScopeHandler | undefined;
   private lastYieldedIndex: number | undefined;
 
@@ -31,21 +32,18 @@ export class OneOfScopeHandler extends BaseScopeHandler {
 
     return this.createFromScopeHandlers(
       scopeHandlerFactory,
-      scopeType,
-      scopeHandlers,
       languageId,
+      scopeHandlers,
     );
   }
 
   static createFromScopeHandlers(
     scopeHandlerFactory: ScopeHandlerFactory,
-    scopeType: OneOfScopeType,
-    scopeHandlers: ScopeHandler[],
     languageId: string,
+    scopeHandlers: ScopeHandler[],
   ): ScopeHandler {
     const getIterationScopeHandler = () =>
       new OneOfScopeHandler(
-        undefined,
         scopeHandlers.map((scopeHandler) =>
           scopeHandlerFactory.create(
             scopeHandler.iterationScopeType,
@@ -57,11 +55,14 @@ export class OneOfScopeHandler extends BaseScopeHandler {
         },
       );
 
-    return new OneOfScopeHandler(
-      scopeType,
-      scopeHandlers,
-      getIterationScopeHandler,
-    );
+    return new OneOfScopeHandler(scopeHandlers, getIterationScopeHandler);
+  }
+
+  private constructor(
+    private scopeHandlers: ScopeHandler[],
+    private getIterationScopeHandler: () => OneOfScopeHandler,
+  ) {
+    super();
   }
 
   get iterationScopeType(): CustomScopeType {
@@ -74,21 +75,13 @@ export class OneOfScopeHandler extends BaseScopeHandler {
     };
   }
 
-  private constructor(
-    public readonly scopeType: OneOfScopeType | undefined,
-    private scopeHandlers: ScopeHandler[],
-    private getIterationScopeHandler: () => OneOfScopeHandler,
-  ) {
-    super();
-  }
-
   *generateScopeCandidates(
     editor: TextEditor,
     position: Position,
     direction: Direction,
     hints: ScopeIteratorRequirements,
   ): Iterable<TargetScope> {
-    // If we have used the iteration scope handler, we only want to yield from its handler.
+    // If we have used an iteration scope handler, we only want to yield additional scopes from its handler.
     if (this.iterationScopeHandler?.lastYieldedIndex != null) {
       const handlerIndex = this.iterationScopeHandler.lastYieldedIndex;
       const handler = this.scopeHandlers[handlerIndex];
diff --git a/packages/cursorless-vscode/src/migrateSnippets.ts b/packages/cursorless-vscode/src/migrateSnippets.ts
@@ -15,71 +15,130 @@ import {
   type VscodeSnippets,
 } from "./VscodeSnippets";
 
+interface Result {
+  migrated: Record<string, string>;
+  migratedPartially: Record<string, string>;
+  skipped: string[];
+}
+
+interface SpokenForms {
+  insertion: Record<string, string>;
+  insertionWithPhrase: Record<string, string>;
+  wrapper: Record<string, string>;
+}
+
 export async function migrateSnippets(
   snippets: VscodeSnippets,
   targetDirectory: string,
+  spokenForms: SpokenForms,
 ) {
-  const userSnippetsDir = snippets.getUserDirectoryStrict();
-  const files = await snippets.getSnippetPaths(userSnippetsDir);
+  const sourceDirectory = snippets.getUserDirectoryStrict();
+  const files = await snippets.getSnippetPaths(sourceDirectory);
+
+  const spokenFormsInverted: SpokenForms = {
+    insertion: swapKeyValue(spokenForms.insertion),
+    insertionWithPhrase: swapKeyValue(
+      spokenForms.insertionWithPhrase,
+      (name) => name.split(".")[0],
+    ),
+    wrapper: swapKeyValue(spokenForms.wrapper),
+  };
+
+  const result: Result = {
+    migrated: {},
+    migratedPartially: {},
+    skipped: [],
+  };
 
   for (const file of files) {
-    await migrateFile(targetDirectory, file);
+    await migrateFile(result, spokenFormsInverted, targetDirectory, file);
   }
 
-  await vscode.window.showInformationMessage(
-    `${files.length} snippet files migrated successfully!`,
-  );
+  await openResultDocument(result, sourceDirectory, targetDirectory);
 }
 
-async function migrateFile(targetDirectory: string, filePath: string) {
+async function migrateFile(
+  result: Result,
+  spokenForms: SpokenForms,
+  targetDirectory: string,
+  filePath: string,
+) {
   const fileName = path.basename(filePath, CURSORLESS_SNIPPETS_SUFFIX);
   const snippetFile = await readLegacyFile(filePath);
   const communitySnippetFile: SnippetFile = { snippets: [] };
+  let hasSkippedSnippet = false;
 
   for (const snippetName in snippetFile) {
     const snippet = snippetFile[snippetName];
+    const phrase =
+      spokenForms.insertion[snippetName] ??
+      spokenForms.insertionWithPhrase[snippetName];
 
     communitySnippetFile.header = {
       name: snippetName,
       description: snippet.description,
-      variables: parseVariables(snippet.variables),
+      phrases: phrase ? [phrase] : undefined,
+      variables: parseVariables(spokenForms, snippetName, snippet.variables),
       insertionScopes: snippet.insertionScopeTypes,
     };
 
     for (const def of snippet.definitions) {
+      if (
+        def.scope?.scopeTypes?.length ||
+        def.scope?.excludeDescendantScopeTypes?.length
+      ) {
+        hasSkippedSnippet = true;
+        continue;
+      }
       communitySnippetFile.snippets.push({
         body: def.body.map((line) => line.replaceAll("\t", "    ")),
         languages: def.scope?.langIds,
-        variables: parseVariables(def.variables),
+        variables: parseVariables(spokenForms, snippetName, def.variables),
         // SKIP: def.scope?.scopeTypes
         // SKIP: def.scope?.excludeDescendantScopeTypes
       });
     }
   }
 
+  if (communitySnippetFile.snippets.length === 0) {
+    result.skipped.push(fileName);
+    return;
+  }
+
+  let destinationName: string;
+
   try {
-    const destinationPath = path.join(targetDirectory, `${fileName}.snippet`);
-    await writeCommunityFile(communitySnippetFile, destinationPath);
+    destinationName = `${fileName}.snippet`;
+    const destinationPath = path.join(targetDirectory, destinationName);
+    await writeCommunityFile(communitySnippetFile, destinationPath, "wx");
   } catch (error: any) {
     if (error.code === "EEXIST") {
-      const destinationPath = path.join(
-        targetDirectory,
-        `${fileName}_CONFLICT.snippet`,
-      );
-      await writeCommunityFile(communitySnippetFile, destinationPath);
+      destinationName = `${fileName}_CONFLICT.snippet`;
+      const destinationPath = path.join(targetDirectory, destinationName);
+      await writeCommunityFile(communitySnippetFile, destinationPath, "w");
     } else {
       throw error;
     }
   }
+
+  if (hasSkippedSnippet) {
+    result.migratedPartially[fileName] = destinationName;
+  } else {
+    result.migrated[fileName] = destinationName;
+  }
 }
 
 function parseVariables(
+  spokenForms: SpokenForms,
+  snippetName: string,
   variables?: Record<string, SnippetVariableLegacy>,
 ): SnippetVariable[] {
   return Object.entries(variables ?? {}).map(
     ([name, variable]): SnippetVariable => {
+      const phrase = spokenForms.wrapper[`${snippetName}.${name}`];
       return {
         name,
+        wrapperPhrases: phrase ? [phrase] : undefined,
         wrapperScope: variable.wrapperScopeType,
         insertionFormatters: variable.formatter
           ? [variable.formatter]
@@ -90,6 +149,52 @@ function parseVariables(
   );
 }
 
+async function openResultDocument(
+  result: Result,
+  sourceDirectory: string,
+  targetDirectory: string,
+) {
+  const migratedKeys = Object.keys(result.migrated).sort();
+  const migratedPartiallyKeys = Object.keys(result.migratedPartially).sort();
+  const skipMessage =
+    "(Snippets containing `scopeTypes` and/or `excludeDescendantScopeTypes` attributes are not supported by community snippets.)";
+
+  const content: string[] = [
+    `# Snippets migrated from Cursorless`,
+    "",
+    `From: ${sourceDirectory}`,
+    `To:   ${targetDirectory}`,
+    "",
+    `## Migrated ${migratedKeys.length} snippet files:`,
+    ...migratedKeys.map((key) => `- ${key} -> ${result.migrated[key]}`),
+    "",
+  ];
+
+  if (migratedPartiallyKeys.length > 0) {
+    content.push(
+      `## Migrated ${migratedPartiallyKeys.length} snippet files partially:`,
+      ...migratedPartiallyKeys.map(
+        (key) => `- ${key} -> ${result.migratedPartially[key]}`,
+      ),
+      skipMessage,
+    );
+  }
+
+  if (result.skipped.length > 0) {
+    content.push(
+      `## Skipped ${result.skipped.length} snippet files:`,
+      ...result.skipped.map((key) => `- ${key}`),
+      skipMessage,
+    );
+  }
+
+  const textDocument = await vscode.workspace.openTextDocument({
+    content: content.join("\n"),
+    language: "markdown",
+  });
+  await vscode.window.showTextDocument(textDocument);
+}
+
 async function readLegacyFile(filePath: string): Promise<SnippetMap> {
   const content = await fs.readFile(filePath, "utf8");
   if (content.length === 0) {
@@ -98,12 +203,25 @@ async function readLegacyFile(filePath: string): Promise<SnippetMap> {
   return JSON.parse(content);
 }
 
-async function writeCommunityFile(snippetFile: SnippetFile, filePath: string) {
+async function writeCommunityFile(
+  snippetFile: SnippetFile,
+  filePath: string,
+  flags: string,
+) {
   const snippetText = serializeSnippetFile(snippetFile);
-  const file = await fs.open(filePath, "wx");
+  const file = await fs.open(filePath, flags);
   try {
     await file.write(snippetText);
   } finally {
     await file.close();
   }
 }
+
+function swapKeyValue(
+  obj: Record<string, string>,
+  map?: (value: string) => string,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [map?.(value) ?? value, key]),
+  );
+}
diff --git a/packages/cursorless-vscode/src/registerCommands.ts b/packages/cursorless-vscode/src/registerCommands.ts
@@ -89,7 +89,7 @@ export function registerCommands(
     ["cursorless.showDocumentation"]: showDocumentation,
     ["cursorless.showInstallationDependencies"]: installationDependencies.show,
 
-    ["cursorless.migrateSnippets"]: (dir) => migrateSnippets(snippets, dir),
+    ["cursorless.migrateSnippets"]: migrateSnippets.bind(null, snippets),
 
     ["cursorless.private.logQuickActions"]: logQuickActions,
 
diff --git a/packages/vscode-common/src/testUtil/openNewEditor.ts b/packages/vscode-common/src/testUtil/openNewEditor.ts

Original file line number	Diff line number	Diff line change
`@@ -142,9 +142,11 @@ function getModifiersFromTarget(`
`142`	`142`	`return target.modifiers;`
`143`	`143`	`}`
`144`	`144`
`145`		`- if (target.mark?.type === "cursor") {`
`146`		`- return [{ type: "containingTokenIfEmpty" }];`
`147`		`- }`
	`145`	`+ // FIXME: Trying to select a word in the file explorer will create weird behavior.`
	`146`	`+ // https://github.com/cursorless-dev/cursorless/issues/2800`
	`147`	`+ // if (target.mark?.type === "cursor") {`
	`148`	`+ // return [{ type: "containingTokenIfEmpty" }];`
	`149`	`+ // }`
`148`	`150`	`}`
`149`	`151`	`return [];`
`150`	`152`	`}`