Merge pull request #81 from vim-denops/improve-batch

👍 Define behaviors of BatchHelper/GatherHelper instances outside of the block

Author: lambdalisue

denops_std/batch/README.md

@@ -67,6 +67,33 @@ export async function main(denops: Denops): Promise<void> {
 }
 ```
 
+The `denops` instance passed to the `batch` block is available even outside of
+the block. It works like a real `denops` instance, mean that you can write code
+like:
+
+```typescript
+import { Denops } from "https://deno.land/x/denops_std/mod.ts";
+import { batch } from "https://deno.land/x/denops_std/batch/mod.ts";
+import * as anonymous from "https://deno.land/x/denops_std/anonymous/mod.ts";
+
+export async function main(denops: Denops): Promise<void> {
+  await batch(denops, async (denops) => {
+    const [id] = anonymous.add(denops, () => {
+      // This code is called outside of 'batch' block
+      // thus the 'denops' instance works like a real one.
+      // That's why you can write code like below
+      if (await denops.eval("&verbose")) {
+        await denops.cmd("echomsg 'VERBOSE'");
+      }
+      await denops.cmd("echomsg 'Hello world'");
+    });
+    await denops.cmd(
+      `command! Test call denops#request('${denops.name}', '${id}', [])`,
+    );
+  });
+}
+```
+
 ### gather
 
 Use `gather()` to call multiple denops functions sequentially without overhead
@@ -88,8 +115,8 @@ export async function main(denops: Denops): Promise<void> {
 
 Not like `batch`, the function can NOT be nested.
 
-Note that `denops.call()`, `denops.batch()`, or `denops.eval()` always return
-falsy value in `gather()`, indicating that you **cannot** write code like below:
+Note that `denops.call()` or `denops.eval()` always return falsy value in
+`gather()`, indicating that you **cannot** write code like below:
 
 ```typescript
 import { Denops } from "https://deno.land/x/denops_std/mod.ts";
@@ -106,3 +133,7 @@ export async function main(denops: Denops): Promise<void> {
   });
 }
 ```
+
+The `denops` instance passed to the `gather` block is NOT available outside of
+the block. An error is thrown when `denops.call()`, `denops.cmd()`, or
+`denops.eval()` is called.

denops_std/batch/batch.ts

@@ -3,16 +3,22 @@ import { Context, Denops, Dispatcher, Meta } from "../deps.ts";
 class BatchHelper implements Denops {
   #denops: Denops;
   #calls: [string, ...unknown[]][];
+  #closed: boolean;
 
   constructor(denops: Denops) {
     this.#denops = denops;
     this.#calls = [];
+    this.#closed = false;
   }
 
   static getCalls(helper: BatchHelper): [string, ...unknown[]][] {
     return helper.#calls;
   }
 
+  static close(helper: BatchHelper): void {
+    helper.#closed = true;
+  }
+
   get name(): string {
     return this.#denops.name;
   }
@@ -30,21 +36,33 @@ class BatchHelper implements Denops {
   }
 
   call(fn: string, ...args: unknown[]): Promise<unknown> {
+    if (this.#closed) {
+      return this.#denops.call(fn, ...args);
+    }
     this.#calls.push([fn, ...args]);
     return Promise.resolve();
   }
 
   batch(...calls: [string, ...unknown[]][]): Promise<unknown[]> {
+    if (this.#closed) {
+      return this.#denops.batch(...calls);
+    }
     this.#calls.push(...calls);
     return Promise.resolve([]);
   }
 
   cmd(cmd: string, ctx: Context = {}): Promise<void> {
+    if (this.#closed) {
+      return this.#denops.cmd(cmd, ctx);
+    }
     this.call("denops#api#cmd", cmd, ctx);
     return Promise.resolve();
   }
 
   eval(expr: string, ctx: Context = {}): Promise<unknown> {
+    if (this.#closed) {
+      return this.#denops.eval(expr, ctx);
+    }
     this.call("denops#api#eval", expr, ctx);
     return Promise.resolve();
   }
@@ -62,7 +80,11 @@ export async function batch(
   main: (helper: BatchHelper) => Promise<void>,
 ): Promise<void> {
   const helper = new BatchHelper(denops);
-  await main(helper);
+  try {
+    await main(helper);
+  } finally {
+    BatchHelper.close(helper);
+  }
   const calls = BatchHelper.getCalls(helper);
   await denops.batch(...calls);
 }

denops_std/batch/batch_test.ts

@@ -1,5 +1,5 @@
 import { assertEquals, test } from "../deps_test.ts";
-import { batch } from "./batch.ts";
+import { batch, BatchHelper } from "./batch.ts";
 
 test({
   mode: "any",
@@ -130,3 +130,33 @@ test({
     ]);
   },
 });
+test({
+  mode: "any",
+  name:
+    "The 'helper' instance passed in batch block is available outside of the block",
+  fn: async (denops) => {
+    await denops.cmd("let g:denops_batch_test = []");
+    await denops.cmd(
+      "command! -nargs=1 DenopsBatchTest let g:denops_batch_test += [<f-args>]",
+    );
+
+    let helper: BatchHelper;
+    await batch(denops, (denops) => {
+      helper = denops;
+      return Promise.resolve();
+    });
+    await helper!.call("execute", "DenopsBatchTest 1");
+    await helper!.batch(["execute", "DenopsBatchTest 1"]);
+    await helper!.cmd("DenopsBatchTest 1");
+    assertEquals(
+      await helper!.eval("add(g:denops_batch_test, string(1))"),
+      ["1", "1", "1", "1"],
+    );
+    assertEquals(await denops.eval("g:denops_batch_test") as string[], [
+      "1",
+      "1",
+      "1",
+      "1",
+    ]);
+  },
+});

denops_std/batch/gather.ts

@@ -3,16 +3,22 @@ import { Context, Denops, Dispatcher, Meta } from "../deps.ts";
 class GatherHelper implements Denops {
   #denops: Denops;
   #calls: [string, ...unknown[]][];
+  #closed: boolean;
 
   constructor(denops: Denops) {
     this.#denops = denops;
     this.#calls = [];
+    this.#closed = false;
   }
 
   static getCalls(helper: GatherHelper): [string, ...unknown[]][] {
     return helper.#calls;
   }
 
+  static close(helper: GatherHelper): void {
+    helper.#closed = true;
+  }
+
   get name(): string {
     return this.#denops.name;
   }
@@ -30,6 +36,11 @@ class GatherHelper implements Denops {
   }
 
   call(fn: string, ...args: unknown[]): Promise<unknown> {
+    if (this.#closed) {
+      throw new Error(
+        "GatherHelper instance is not available outside of 'gather' block",
+      );
+    }
     this.#calls.push([fn, ...args]);
     return Promise.resolve();
   }
@@ -39,11 +50,21 @@ class GatherHelper implements Denops {
   }
 
   cmd(cmd: string, ctx: Context = {}): Promise<void> {
+    if (this.#closed) {
+      throw new Error(
+        "GatherHelper instance is not available outside of 'gather' block",
+      );
+    }
     this.call("denops#api#cmd", cmd, ctx);
     return Promise.resolve();
   }
 
   eval(expr: string, ctx: Context = {}): Promise<unknown> {
+    if (this.#closed) {
+      throw new Error(
+        "GatherHelper instance is not available outside of 'gather' block",
+      );
+    }
     this.call("denops#api#eval", expr, ctx);
     return Promise.resolve();
   }
@@ -61,7 +82,11 @@ export async function gather(
   main: (helper: GatherHelper) => Promise<void>,
 ): Promise<unknown[]> {
   const helper = new GatherHelper(denops);
-  await main(helper);
+  try {
+    await main(helper);
+  } finally {
+    GatherHelper.close(helper);
+  }
   const calls = GatherHelper.getCalls(helper);
   return await denops.batch(...calls);
 }

denops_std/batch/gather_test.ts

@@ -1,5 +1,5 @@
 import { assertEquals, assertThrowsAsync, test } from "../deps_test.ts";
-import { gather } from "./gather.ts";
+import { gather, GatherHelper } from "./gather.ts";
 
 test({
   mode: "any",
@@ -57,3 +57,39 @@ test({
   },
   prelude: ["let g:denops#enable_workaround_vim_before_8_2_3081 = 1"],
 });
+test({
+  mode: "any",
+  name:
+    "The 'helper' instance passed in gather block is NOT available outside of the block",
+  fn: async (denops) => {
+    await denops.cmd("let g:denops_gather_test = 0");
+    await denops.cmd("command! DenopsGatherTest let g:denops_gather_test += 1");
+
+    let helper: GatherHelper;
+    await gather(denops, (denops) => {
+      helper = denops;
+      return Promise.resolve();
+    });
+    await assertThrowsAsync(
+      async () => {
+        await helper!.call("execute", "DenopsGatherTest");
+      },
+      undefined,
+      "not available outside",
+    );
+    await assertThrowsAsync(
+      async () => {
+        await helper.cmd("DenopsGatherTest");
+      },
+      undefined,
+      "not available outside",
+    );
+    await assertThrowsAsync(
+      async () => {
+        const _ = await helper.eval("v:version");
+      },
+      undefined,
+      "not available outside",
+    );
+  },
+});