👍 Add gather function on batch module

Author: lambdalisue

denops_std/batch/gather.ts

@@ -0,0 +1,69 @@
+import { Context, Denops, Dispatcher, Meta } from "../deps.ts";
+
+class GatherHelper implements Denops {
+  #denops: Denops;
+  #calls: [string, ...unknown[]][];
+
+  constructor(denops: Denops) {
+    this.#denops = denops;
+    this.#calls = [];
+  }
+
+  static getCalls(helper: GatherHelper): [string, ...unknown[]][] {
+    return helper.#calls;
+  }
+
+  get name(): string {
+    return this.#denops.name;
+  }
+
+  get meta(): Meta {
+    return this.#denops.meta;
+  }
+
+  get dispatcher(): Dispatcher {
+    return this.#denops.dispatcher;
+  }
+
+  set dispatcher(dispatcher: Dispatcher) {
+    this.#denops.dispatcher = dispatcher;
+  }
+
+  call(fn: string, ...args: unknown[]): Promise<unknown> {
+    this.#calls.push([fn, ...args]);
+    return Promise.resolve();
+  }
+
+  batch(..._calls: [string, ...unknown[]][]): Promise<unknown[]> {
+    throw new Error("The 'batch' method is not available on GatherHelper.");
+  }
+
+  cmd(cmd: string, ctx: Context = {}): Promise<void> {
+    this.call("denops#api#cmd", cmd, ctx);
+    return Promise.resolve();
+  }
+
+  eval(expr: string, ctx: Context = {}): Promise<unknown> {
+    this.call("denops#api#eval", expr, ctx);
+    return Promise.resolve();
+  }
+
+  dispatch(name: string, fn: string, ...args: unknown[]): Promise<unknown> {
+    return this.#denops.dispatch(name, fn, ...args);
+  }
+}
+
+/**
+ * Perform gather call
+ */
+export async function gather(
+  denops: Denops,
+  main: (helper: GatherHelper) => Promise<void>,
+): Promise<unknown[]> {
+  const helper = new GatherHelper(denops);
+  await main(helper);
+  const calls = GatherHelper.getCalls(helper);
+  return await denops.batch(...calls);
+}
+
+export type { GatherHelper };

denops_std/batch/gather_test.ts

@@ -0,0 +1,58 @@
+import { assertEquals, assertThrowsAsync, test } from "../deps_test.ts";
+import { gather } from "./gather.ts";
+
+test({
+  mode: "any",
+  name: "gather() sequentially execute 'denops.call()'.",
+  fn: async (denops) => {
+    const results = await gather(denops, async (denops) => {
+      await denops.call("range", 0);
+      await denops.call("range", 1);
+      await denops.call("range", 2);
+    });
+    assertEquals(results, [[], [0], [0, 1]]);
+  },
+});
+test({
+  mode: "any",
+  name: "gather() throws an error when 'denops.cmd()' is called.",
+  fn: async (denops) => {
+    await denops.cmd("let g:denops_gather_test = 0");
+    await denops.cmd("command! DenopsGatherTest let g:denops_gather_test += 1");
+    const results = await gather(denops, async (denops) => {
+      await denops.cmd("DenopsGatherTest");
+      await denops.cmd("DenopsGatherTest");
+      await denops.cmd("DenopsGatherTest");
+    });
+    assertEquals(results, [0, 0, 0]);
+    assertEquals(await denops.eval("g:denops_gather_test") as number, 3);
+  },
+});
+test({
+  mode: "any",
+  name: "gather() sequentially execute 'denops.eval()'.",
+  fn: async (denops) => {
+    await denops.cmd("let g:denops_gather_test = 10");
+    const results = await gather(denops, async (denops) => {
+      await denops.eval("g:denops_gather_test + 1");
+      await denops.eval("g:denops_gather_test - 1");
+      await denops.eval("g:denops_gather_test * 10");
+    });
+    assertEquals(results, [11, 9, 100]);
+  },
+});
+test({
+  mode: "any",
+  name: "gather() throws an error when 'denops.batch()' is called.",
+  fn: async (denops) => {
+    await assertThrowsAsync(
+      async () => {
+        await gather(denops, async (denops) => {
+          await denops.batch();
+        });
+      },
+      undefined,
+      "method is not available",
+    );
+  },
+});