Free actions from vscode dependencies

src/actions/Actions.ts

@@ -1,27 +1,29 @@
 import { Graph } from "../typings/Types";
 import { ActionRecord } from "./actions.types";
 import {
-  CommentLines,
+  ToggleLineComment,
   ExtractVariable,
-  IndentLines,
-  OutdentLines,
+  IndentLine,
+  OutdentLine,
   Rename,
   RevealDefinition,
   RevealTypeDefinition,
   ShowDebugHover,
   ShowHover,
   ShowQuickFix,
   ShowReferences,
-} from "./MakeshiftActions";
+  CopyToClipboard,
+  Fold,
+  Unfold,
+} from "./SimpleIdeCommandActions";
 import { Bring, Move, Swap } from "./BringMoveSwap";
 import Call from "./Call";
 import Clear from "./Clear";
-import { Copy, Cut } from "./CutCopy";
+import { CutToClipboard } from "./CutToClipboard";
 import Deselect from "./Deselect";
 import { EditNew, EditNewAfter, EditNewBefore } from "./EditNew";
 import ExecuteCommand from "./ExecuteCommand";
-import { FindInFiles } from "./Find";
-import { Fold, Unfold } from "./Fold";
+import { FindInWorkspace } from "./Find";
 import FollowLink from "./FollowLink";
 import GenerateSnippet from "./GenerateSnippet";
 import GetText from "./GetText";
@@ -36,7 +38,7 @@ import {
   InsertEmptyLinesAround,
 } from "./InsertEmptyLines";
 import InsertSnippet from "./InsertSnippet";
-import { Paste } from "./Paste";
+import { PasteFromClipboard } from "./PasteFromClipboard";
 import Remove from "./Remove";
 import Replace from "./Replace";
 import Rewrap from "./Rewrap";
@@ -56,30 +58,30 @@ class Actions implements ActionRecord {
 
   callAsFunction = new Call(this.graph);
   clearAndSetSelection = new Clear(this.graph);
-  copyToClipboard = new Copy(this.graph);
-  cutToClipboard = new Cut(this.graph);
+  copyToClipboard = new CopyToClipboard(this.graph);
+  cutToClipboard = new CutToClipboard(this.graph);
   deselect = new Deselect(this.graph);
   editNew = new EditNew(this.graph);
   editNewLineAfter = new EditNewAfter(this.graph);
   editNewLineBefore = new EditNewBefore(this.graph);
   executeCommand = new ExecuteCommand(this.graph);
   extractVariable = new ExtractVariable(this.graph);
-  findInWorkspace = new FindInFiles(this.graph);
+  findInWorkspace = new FindInWorkspace(this.graph);
   foldRegion = new Fold(this.graph);
   followLink = new FollowLink(this.graph);
   generateSnippet = new GenerateSnippet(this.graph);
   getText = new GetText(this.graph);
   highlight = new Highlight(this.graph);
-  indentLine = new IndentLines(this.graph);
+  indentLine = new IndentLine(this.graph);
   insertCopyAfter = new InsertCopyAfter(this.graph);
   insertCopyBefore = new InsertCopyBefore(this.graph);
   insertEmptyLineAfter = new InsertEmptyLineAfter(this.graph);
   insertEmptyLineBefore = new InsertEmptyLineBefore(this.graph);
   insertEmptyLinesAround = new InsertEmptyLinesAround(this.graph);
   insertSnippet = new InsertSnippet(this.graph);
   moveToTarget = new Move(this.graph);
-  outdentLine = new OutdentLines(this.graph);
-  pasteFromClipboard = new Paste(this.graph);
+  outdentLine = new OutdentLine(this.graph);
+  pasteFromClipboard = new PasteFromClipboard(this.graph);
   randomizeTargets = new Random(this.graph);
   remove = new Remove(this.graph);
   rename = new Rename(this.graph);
@@ -102,7 +104,7 @@ class Actions implements ActionRecord {
   sortTargets = new Sort(this.graph);
   swapTargets = new Swap(this.graph);
   toggleLineBreakpoint = new ToggleBreakpoint(this.graph);
-  toggleLineComment = new CommentLines(this.graph);
+  toggleLineComment = new ToggleLineComment(this.graph);
   unfoldRegion = new Unfold(this.graph);
   wrapWithPairedDelimiter = new Wrap(this.graph);
   wrapWithSnippet = new WrapWithSnippet(this.graph);

src/actions/BringMoveSwap.ts

@@ -1,6 +1,9 @@
-import { Selection, TextEditor } from "@cursorless/common";
+import {
+  RangeExpansionBehavior,
+  Selection,
+  TextEditor,
+} from "@cursorless/common";
 import { flatten } from "lodash";
-import { DecorationRangeBehavior } from "vscode";
 import {
   getSelectionInfo,
   performEditsAndUpdateFullSelectionInfos,
@@ -169,15 +172,15 @@ class BringMoveSwap implements Action {
               getSelectionInfo(
                 editor.document,
                 range.toSelection(originalTarget.isReversed),
-                DecorationRangeBehavior.OpenOpen,
+                RangeExpansionBehavior.openOpen,
               ),
           );
 
           const cursorSelectionInfos = editor.selections.map((selection) =>
             getSelectionInfo(
               editor.document,
               selection,
-              DecorationRangeBehavior.ClosedClosed,
+              RangeExpansionBehavior.closedClosed,
             ),
           );
 

src/actions/CallbackAction.ts

@@ -0,0 +1,139 @@
+import { EditableTextEditor, TextEditor } from "@cursorless/common";
+import { flatten } from "lodash";
+import { selectionToThatTarget } from "../core/commandRunner/selectionToThatTarget";
+import { callFunctionAndUpdateSelections } from "../core/updateSelections/updateSelections";
+import ide from "../libs/cursorless-engine/singletons/ide.singleton";
+import { Target } from "../typings/target.types";
+import { Graph } from "../typings/Types";
+import {
+  setSelectionsAndFocusEditor,
+  setSelectionsWithoutFocusingEditor,
+} from "../util/setSelectionsAndFocusEditor";
+import {
+  ensureSingleEditor,
+  ensureSingleTarget,
+  runOnTargetsForEachEditor,
+  runOnTargetsForEachEditorSequentially,
+} from "../util/targetUtils";
+import { Action, ActionReturnValue } from "./actions.types";
+
+interface CallbackOptions {
+  callback: (editor: EditableTextEditor, targets: Target[]) => Promise<void>;
+  ensureSingleEditor: boolean;
+  ensureSingleTarget: boolean;
+  setSelection: boolean;
+  restoreSelection: boolean;
+  showDecorations: boolean;
+}
+
+/**
+ * This is a helper action that is used internally to implement various actions.
+ * It takes a {@link CallbackOptions.callback callback} that is called once for
+ * each editor, receiving all the targets that are in the given editor.
+ */
+export class CallbackAction implements Action {
+  constructor(private graph: Graph) {
+    this.run = this.run.bind(this);
+  }
+
+  async run(
+    [targets]: [Target[]],
+    options: CallbackOptions,
+  ): Promise<ActionReturnValue> {
+    if (options.showDecorations) {
+      await this.graph.editStyles.displayPendingEditDecorations(
+        targets,
+        this.graph.editStyles.referenced,
+      );
+    }
+
+    if (options.ensureSingleEditor) {
+      ensureSingleEditor(targets);
+    }
+
+    if (options.ensureSingleTarget) {
+      ensureSingleTarget(targets);
+    }
+
+    const originalEditor = ide().activeEditableTextEditor;
+
+    // If we are relying on selections we have to wait for one editor to finish
+    // before moving the selection to the next
+    const runOnTargets = options.setSelection
+      ? runOnTargetsForEachEditorSequentially
+      : runOnTargetsForEachEditor;
+
+    const thatTargets = flatten(
+      await runOnTargets(targets, (editor, targets) =>
+        this.runForEditor(options, editor, targets),
+      ),
+    );
+
+    // If necessary focus back original editor
+    if (
+      options.setSelection &&
+      options.restoreSelection &&
+      originalEditor != null &&
+      !originalEditor.isActive
+    ) {
+      // NB: We just do one editor focus at the end, instead of using
+      // setSelectionsAndFocusEditor because the command might operate on
+      // multiple editors, so we just do one focus at the end.
+      await originalEditor.focus();
+    }
+
+    return { thatTargets };
+  }
+
+  private async runForEditor(
+    options: CallbackOptions,
+    editor: TextEditor,
+    targets: Target[],
+  ): Promise<Target[]> {
+    const editableEditor = ide().getEditableTextEditor(editor);
+    const originalSelections = editor.selections;
+    const originalEditorVersion = editor.document.version;
+    const targetSelections = targets.map((target) => target.contentSelection);
+
+    // For this callback/command to the work we have to have the correct editor focused
+    if (options.setSelection) {
+      await setSelectionsAndFocusEditor(
+        editableEditor,
+        targetSelections,
+        false,
+      );
+    }
+
+    const [updatedOriginalSelections, updatedTargetSelections] =
+      await callFunctionAndUpdateSelections(
+        this.graph.rangeUpdater,
+        () => options.callback(editableEditor, targets),
+        editor.document,
+        [originalSelections, targetSelections],
+      );
+
+    // Reset original selections
+    if (options.setSelection && options.restoreSelection) {
+      // NB: We don't focus the editor here because we'll do that at the
+      // very end. This code can run on multiple editors in the course of
+      // one command, so we want to avoid focusing the editor multiple
+      // times.
+      setSelectionsWithoutFocusingEditor(
+        editableEditor,
+        updatedOriginalSelections,
+      );
+    }
+
+    // If the document hasn't changed then we just return the original targets
+    // so that we preserve their rich types, but if it has changed then we
+    // just downgrade them to untyped targets
+    return editor.document.version === originalEditorVersion
+      ? targets
+      : updatedTargetSelections.map((selection) =>
+          selectionToThatTarget({
+            editor,
+            selection,
+          }),
+        );
+  }
+}