feat(vscode): implemented quickPickProject (#1025)

Author: alestiago

extensions/vscode/src/test/suite/utils/dart-frog-application.test.ts

@@ -265,7 +265,7 @@ suite("quickPickApplication", () => {
   });
 
   suite("returns", () => {
-    test("returns undefined when dismissed", async () => {
+    test("undefined when dismissed", async () => {
       const application = quickPickApplication({}, [
         application1,
         application2,
@@ -280,7 +280,7 @@ suite("quickPickApplication", () => {
       assert.strictEqual(selection, undefined);
     });
 
-    test("returns application when selected", async () => {
+    test("application when selected", async () => {
       const application = quickPickApplication({}, [
         application1,
         application2,

extensions/vscode/src/test/suite/utils/dart-frog-project.test.ts

@@ -647,6 +647,272 @@ suite("resolveDartFrogProjectPathFromActiveTextEditor", () => {
   });
 });
 
+suite("quickPickProject", () => {
+  let vscodeStub: any;
+  let quickPickProject: any;
+  let quickPick: any;
+
+  const projectPath1 = "home/project1";
+  const projectPath2 = "home/project2";
+
+  beforeEach(() => {
+    vscodeStub = {
+      window: {
+        createQuickPick: sinon.stub(),
+      },
+    };
+
+    quickPickProject = proxyquire("../../../utils/dart-frog-project", {
+      vscode: vscodeStub,
+    }).quickPickProject;
+
+    quickPick = sinon.stub();
+    vscodeStub.window.createQuickPick.returns(quickPick);
+    quickPick.show = sinon.stub();
+    quickPick.dispose = sinon.stub();
+    quickPick.onDidChangeSelection = sinon.stub();
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  suite("placeholder", () => {
+    test("is defined by default", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.placeholder, "Select a Dart Frog project");
+    });
+
+    test("can be overridden", async () => {
+      const placeHolder = "placeholder";
+      const project = quickPickProject(
+        {
+          placeHolder,
+        },
+        [projectPath1, projectPath2]
+      );
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.placeholder, placeHolder);
+    });
+  });
+
+  suite("ignoreFocusOut", () => {
+    test("is true by default", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.ignoreFocusOut, true);
+    });
+
+    test("can be overridden", async () => {
+      const ignoreFocusOut = false;
+      const project = quickPickProject(
+        {
+          ignoreFocusOut,
+        },
+        [projectPath1, projectPath2]
+      );
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.ignoreFocusOut, ignoreFocusOut);
+    });
+  });
+
+  suite("canSelectMany", () => {
+    test("is false by default", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.canSelectMany, false);
+    });
+
+    test("can be overridden", async () => {
+      const canPickMany = true;
+      const project = quickPickProject(
+        {
+          canPickMany,
+        },
+        [projectPath1, projectPath2]
+      );
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([]);
+
+      await project;
+
+      assert.strictEqual(quickPick.canSelectMany, canPickMany);
+    });
+  });
+
+  test("busy is false by default", async () => {
+    const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+    const onDidChangeSelection =
+      quickPick.onDidChangeSelection.getCall(0).args[0];
+    onDidChangeSelection([]);
+
+    await project;
+
+    assert.strictEqual(quickPick.busy, false);
+  });
+
+  test("shows appropiate items for resolved projects", async () => {
+    const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+    const onDidChangeSelection =
+      quickPick.onDidChangeSelection.getCall(0).args[0];
+    onDidChangeSelection([]);
+
+    await project;
+
+    const items = quickPick.items;
+
+    sinon.assert.match(items[0], {
+      label: `$(dart-frog) project1`,
+      description: projectPath1,
+      projectPath: projectPath1,
+    });
+    sinon.assert.match(items[1], {
+      label: `$(dart-frog) project2`,
+      description: projectPath2,
+      projectPath: projectPath2,
+    });
+  });
+
+  test("shows the quick pick", async () => {
+    const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+    const onDidChangeSelection =
+      quickPick.onDidChangeSelection.getCall(0).args[0];
+    onDidChangeSelection([]);
+
+    await project;
+
+    sinon.assert.calledOnce(quickPick.show);
+  });
+
+  suite("onDidSelectItem", () => {
+    test("is called when an item is selected", async () => {
+      const onDidSelectItem = sinon.stub();
+      const project = quickPickProject(
+        {
+          onDidSelectItem,
+        },
+        [projectPath1, projectPath2]
+      );
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([{ projectPath: projectPath1 }]);
+
+      await project;
+
+      sinon.assert.calledOnceWithExactly(onDidSelectItem, {
+        projectPath: projectPath1,
+      });
+    });
+
+    test("is not called when an item is dismissed", async () => {
+      const onDidSelectItem = sinon.stub();
+      const project = quickPickProject(
+        {
+          onDidSelectItem,
+        },
+        [projectPath1, projectPath2]
+      );
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection(undefined);
+
+      await project;
+
+      sinon.assert.notCalled(onDidSelectItem);
+    });
+  });
+
+  suite("dispose", () => {
+    test("is called when an item is selected", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([{ projectPath: projectPath1 }]);
+
+      await project;
+
+      sinon.assert.calledOnce(quickPick.dispose);
+    });
+
+    test("is called when an item is dismissed", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection(undefined);
+
+      await project;
+
+      sinon.assert.calledOnce(quickPick.dispose);
+    });
+  });
+
+  suite("returns", () => {
+    test("undefined when dismissed", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection(undefined);
+
+      const selection = await project;
+
+      assert.strictEqual(selection, undefined);
+    });
+
+    test("application when selected", async () => {
+      const project = quickPickProject({}, [projectPath1, projectPath2]);
+
+      const onDidChangeSelection =
+        quickPick.onDidChangeSelection.getCall(0).args[0];
+      onDidChangeSelection([{ projectPath: projectPath1 }]);
+
+      const selection = await project;
+
+      assert.strictEqual(selection, projectPath1);
+    });
+  });
+});
+
 /**
  * Example of a pubspec.yaml file that depends on Dart Frog.
  *

extensions/vscode/src/utils/dart-frog-project.ts

@@ -5,7 +5,14 @@
 
 const fs = require("fs");
 const path = require("node:path");
-import { window, workspace } from "vscode";
+import {
+  QuickInputButton,
+  QuickPickItem,
+  QuickPickItemKind,
+  QuickPickOptions,
+  window,
+  workspace,
+} from "vscode";
 
 /**
  * Normalizes a file path to Dart Frog route path from the root of the
@@ -247,3 +254,64 @@ export function resolveDartFrogProjectPathFromActiveTextEditor(
 
   return undefined;
 }
+
+/**
+ * Prompts the user to select a Dart Frog project from a list of resolved Dart
+ * Frog projects.
+ *
+ * @param options The options for the {@link QuickPick}.
+ * @param projectPaths The resolved project paths.
+ * @returns The selected project path or `undefined` if the user cancelled the
+ * selection.
+ */
+export async function quickPickProject(
+  options: QuickPickOptions,
+  projectPaths: string[]
+) {
+  const quickPick = window.createQuickPick<PickableDartFrogProject>();
+  quickPick.placeholder = options.placeHolder ?? "Select a Dart Frog project";
+  quickPick.busy = false;
+  quickPick.ignoreFocusOut = options.ignoreFocusOut ?? true;
+  quickPick.canSelectMany = options.canPickMany ?? false;
+  quickPick.items = projectPaths.map(
+    (projectPath) => new PickableDartFrogProject(projectPath)
+  );
+  quickPick.show();
+
+  return new Promise<string | undefined>((resolve) => {
+    quickPick.onDidChangeSelection((value) => {
+      quickPick.dispose();
+
+      const selection =
+        !value || value.length === 0 ? undefined : value[0]!.projectPath;
+      if (selection) {
+        options.onDidSelectItem?.(value[0]);
+      }
+
+      resolve(selection);
+    });
+  });
+}
+
+/**
+ * A {@link QuickPickItem} that represents a Dart Frog project.
+ *
+ * @see {@link quickPickApplication}
+ */
+class PickableDartFrogProject implements QuickPickItem {
+  constructor(dartFrogProjectPath: string) {
+    this.label = `$(dart-frog) ${path.basename(dartFrogProjectPath)}`;
+    this.description = dartFrogProjectPath;
+    this.projectPath = dartFrogProjectPath;
+  }
+
+  public readonly projectPath: string;
+
+  label: string;
+  kind?: QuickPickItemKind | undefined;
+  description?: string | undefined;
+  detail?: string | undefined;
+  picked?: boolean | undefined;
+  alwaysShow?: boolean | undefined;
+  buttons?: readonly QuickInputButton[] | undefined;
+}