Merge pull request #340 from vim-denops/wait

👍 Automatically wait the target plugin on `denops.dispatch()`

Author: lambdalisue

denops/@denops-private/denops.ts

@@ -13,7 +13,7 @@ const isBatchReturn = is.TupleOf([is.Array, is.String] as const);
 
 export type Host = Pick<HostOrigin, "redraw" | "call" | "batch">;
 
-export type Service = Pick<ServiceOrigin, "dispatch">;
+export type Service = Pick<ServiceOrigin, "dispatch" | "waitLoaded">;
 
 export class DenopsImpl implements Denops {
   readonly name: string;
@@ -67,12 +67,13 @@ export class DenopsImpl implements Denops {
     return this.#host.call("denops#api#eval", expr, ctx);
   }
 
-  dispatch(
+  async dispatch(
     name: string,
     fn: string,
     ...args: unknown[]
   ): Promise<unknown> {
-    return this.#service.dispatch(name, fn, args);
+    await this.#service.waitLoaded(name);
+    return await this.#service.dispatch(name, fn, args);
   }
 }
 

denops/@denops-private/denops_test.ts

@@ -1,9 +1,11 @@
 import type { Meta } from "https://deno.land/x/denops_core@v6.0.5/mod.ts";
+import { assertEquals } from "https://deno.land/std@0.217.0/assert/mod.ts";
 import {
   assertSpyCall,
   stub,
 } from "https://deno.land/std@0.217.0/testing/mock.ts";
 import { DenopsImpl, Host, Service } from "./denops.ts";
+import { promiseState } from "https://deno.land/x/async@v2.1.0/mod.ts";
 import { unimplemented } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 
 Deno.test("DenopsImpl", async (t) => {
@@ -20,6 +22,7 @@ Deno.test("DenopsImpl", async (t) => {
   };
   const service: Service = {
     dispatch: () => unimplemented(),
+    waitLoaded: () => unimplemented(),
   };
   const denops = new DenopsImpl("dummy", meta, host, service);
 
@@ -93,14 +96,41 @@ Deno.test("DenopsImpl", async (t) => {
   });
 
   await t.step("dispatch() calls service.dispatch()", async () => {
-    const s = stub(service, "dispatch");
+    const s1 = stub(service, "waitLoaded", () => Promise.resolve());
+    const s2 = stub(service, "dispatch", () => Promise.resolve());
     try {
       await denops.dispatch("dummy", "fn", "args");
-      assertSpyCall(s, 0, {
+      assertSpyCall(s1, 0, {
+        args: ["dummy"],
+      });
+      assertSpyCall(s2, 0, {
         args: ["dummy", "fn", ["args"]],
       });
     } finally {
-      s.restore();
+      s1.restore();
+      s2.restore();
     }
   });
+
+  await t.step(
+    "dispatch() internally waits 'service.waitLoaded()' before 'service.dispatch()'",
+    async () => {
+      const { promise, resolve } = Promise.withResolvers<void>();
+      const s1 = stub(service, "waitLoaded", () => promise);
+      const s2 = stub(service, "dispatch", () => Promise.resolve());
+      try {
+        const p = denops.dispatch("dummy", "fn", "args");
+        assertEquals(await promiseState(p), "pending");
+        assertEquals(s1.calls.length, 1);
+        assertEquals(s2.calls.length, 0);
+        resolve();
+        assertEquals(await promiseState(p), "fulfilled");
+        assertEquals(s1.calls.length, 1);
+        assertEquals(s2.calls.length, 1);
+      } finally {
+        s1.restore();
+        s2.restore();
+      }
+    },
+  );
 });

denops/@denops-private/service.ts

@@ -6,23 +6,37 @@ import { toFileUrl } from "https://deno.land/std@0.217.0/path/mod.ts";
 import { toErrorObject } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 import { DenopsImpl, Host } from "./denops.ts";
 
+// We can use `PromiseWithResolvers<void>` but Deno 1.38 doesn't have `PromiseWithResolvers`
+type Waiter = {
+  promise: Promise<void>;
+  resolve: () => void;
+};
+
 /**
  * Service manage plugins and is visible from the host (Vim/Neovim) through `invoke()` function.
  */
 export class Service implements Disposable {
   #plugins: Map<string, Plugin> = new Map();
+  #waiters: Map<string, Waiter> = new Map();
   #meta: Meta;
   #host?: Host;
 
   constructor(meta: Meta) {
     this.#meta = meta;
   }
 
+  #getWaiter(name: string): Waiter {
+    if (!this.#waiters.has(name)) {
+      this.#waiters.set(name, Promise.withResolvers());
+    }
+    return this.#waiters.get(name)!;
+  }
+
   bind(host: Host): void {
     this.#host = host;
   }
 
-  load(
+  async load(
     name: string,
     script: string,
     suffix = "",
@@ -35,12 +49,13 @@ export class Service implements Disposable {
       if (this.#meta.mode === "debug") {
         console.log(`A denops plugin '${name}' is already loaded. Skip`);
       }
-      return Promise.resolve();
+      return;
     }
     const denops = new DenopsImpl(name, this.#meta, this.#host, this);
     plugin = new Plugin(denops, name, script);
     this.#plugins.set(name, plugin);
-    return plugin.load(suffix);
+    await plugin.load(suffix);
+    this.#getWaiter(name).resolve();
   }
 
   reload(
@@ -54,12 +69,17 @@ export class Service implements Disposable {
       return Promise.resolve();
     }
     this.#plugins.delete(name);
+    this.#waiters.delete(name);
     // Import module with fragment so that reload works properly
     // https://github.com/vim-denops/denops.vim/issues/227
     const suffix = `#${performance.now()}`;
     return this.load(name, plugin.script, suffix);
   }
 
+  waitLoaded(name: string): Promise<void> {
+    return this.#getWaiter(name).promise;
+  }
+
   async #dispatch(name: string, fn: string, args: unknown[]): Promise<unknown> {
     const plugin = this.#plugins.get(name);
     if (!plugin) {

denops/@denops-private/service_test.ts

@@ -1,18 +1,19 @@
 import {
   assert,
+  assertEquals,
   assertMatch,
   assertRejects,
-  assertThrows,
 } from "https://deno.land/std@0.217.0/assert/mod.ts";
 import {
   assertSpyCall,
   assertSpyCalls,
   stub,
 } from "https://deno.land/std@0.217.0/testing/mock.ts";
 import type { Meta } from "https://deno.land/x/denops_core@v6.0.5/mod.ts";
+import { promiseState } from "https://deno.land/x/async@v2.1.0/mod.ts";
+import { unimplemented } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 import type { Host } from "./denops.ts";
 import { Service } from "./service.ts";
-import { unimplemented } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 
 const scriptValid =
   new URL("./testdata/dummy_valid_plugin.ts", import.meta.url).href;
@@ -33,8 +34,8 @@ Deno.test("Service", async (t) => {
   };
   const service = new Service(meta);
 
-  await t.step("load() throws an error when no host is bound", () => {
-    assertThrows(
+  await t.step("load() rejects an error when no host is bound", async () => {
+    await assertRejects(
       () => service.load("dummy", scriptValid),
       Error,
       "No host is bound to the service",
@@ -61,6 +62,15 @@ Deno.test("Service", async (t) => {
 
   service.bind(host);
 
+  const waitLoaded = service.waitLoaded("dummy");
+
+  await t.step(
+    "the result promise of waitLoaded() is 'pending' when the plugin is not loaded yet",
+    async () => {
+      assertEquals(await promiseState(waitLoaded), "pending");
+    },
+  );
+
   await t.step("load() loads plugin and emits autocmd events", async () => {
     const s = stub(host, "call");
     try {
@@ -92,6 +102,13 @@ Deno.test("Service", async (t) => {
     }
   });
 
+  await t.step(
+    "the result promise of waitLoaded() become 'fulfilled' when the plugin is loaded",
+    async () => {
+      assertEquals(await promiseState(waitLoaded), "fulfilled");
+    },
+  );
+
   await t.step(
     "load() loads plugin and emits autocmd events (failure)",
     async () => {