👍 Disable denops instance passed to gather block outside of the block

Author: lambdalisue

denops_std/batch/README.md

@@ -88,8 +88,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 +106,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/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",
+    );
+  },
+});