Merge pull request #348 from vim-denops/support-interrupt

👍 Add `denops#interrupt()`

Author: lambdalisue

autoload/denops.vim

@@ -25,6 +25,14 @@ function! denops#request_async(name, method, params, success, failure) abort
         \)
 endfunction
 
+function! denops#interrupt(...) abort
+  let l:args = a:0 ? [a:1] : []
+  call denops#server#wait_async({ -> denops#_internal#server#chan#notify(
+        \ 'invoke',
+        \ ['interrupt', l:args],
+        \)})
+endfunction
+
 " Configuration
 call denops#_internal#conf#define('denops#disabled', 0)
 call denops#_internal#conf#define('denops#deno', 'deno')

denops/@denops-private/denops.ts

@@ -8,7 +8,10 @@ const isBatchReturn = is.TupleOf([is.Array, is.String] as const);
 
 export type Host = Pick<HostOrigin, "redraw" | "call" | "batch">;
 
-export type Service = Pick<ServiceOrigin, "dispatch" | "waitLoaded">;
+export type Service = Pick<
+  ServiceOrigin,
+  "dispatch" | "waitLoaded" | "interrupted"
+>;
 
 export class DenopsImpl implements Denops {
   readonly name: string;
@@ -32,6 +35,10 @@ export class DenopsImpl implements Denops {
     this.#service = service;
   }
 
+  get interrupted(): AbortSignal {
+    return this.#service.interrupted;
+  }
+
   redraw(force?: boolean): Promise<void> {
     return this.#host.redraw(force);
   }

denops/@denops-private/denops_test.ts

@@ -1,5 +1,5 @@
 import type { Meta } from "jsr:@denops/[email protected]";
-import { assertEquals } from "jsr:@std/[email protected]";
+import { assertEquals, assertInstanceOf } from "jsr:@std/[email protected]";
 import { assertSpyCall, stub } from "jsr:@std/[email protected]/mock";
 import { promiseState } from "jsr:@lambdalisue/[email protected]";
 import { unimplemented } from "jsr:@lambdalisue/[email protected]";
@@ -20,9 +20,14 @@ Deno.test("DenopsImpl", async (t) => {
   const service: Service = {
     dispatch: () => unimplemented(),
     waitLoaded: () => unimplemented(),
+    interrupted: new AbortController().signal,
   };
   const denops = new DenopsImpl("dummy", meta, host, service);
 
+  await t.step("interrupted returns AbortSignal instance", () => {
+    assertInstanceOf(denops.interrupted, AbortSignal);
+  });
+
   await t.step("redraw() calls host.redraw()", async () => {
     using s = stub(host, "redraw");
     await denops.redraw();

denops/@denops-private/host.ts

@@ -50,6 +50,7 @@ export type Service = {
   bind(host: Host): void;
   load(name: string, script: string): Promise<void>;
   reload(name: string): Promise<void>;
+  interrupt(reason?: unknown): void;
   dispatch(name: string, fn: string, args: unknown[]): Promise<unknown>;
   dispatchAsync(
     name: string,
@@ -74,6 +75,11 @@ export function invoke(
       return service.reload(
         ...ensure(args, is.TupleOf([is.String] as const)),
       );
+    case "interrupt":
+      service.interrupt(
+        ...ensure(args, is.ParametersOf([is.OptionalOf(is.Unknown)] as const)),
+      );
+      return Promise.resolve();
     case "dispatch":
       return service.dispatch(
         ...ensure(args, is.TupleOf([is.String, is.String, is.Array] as const)),

denops/@denops-private/host/nvim_test.ts

@@ -24,6 +24,7 @@ Deno.test("Neovim", async (t) => {
         bind: () => unimplemented(),
         load: () => unimplemented(),
         reload: () => unimplemented(),
+        interrupt: () => unimplemented(),
         dispatch: () => unimplemented(),
         dispatchAsync: () => unimplemented(),
       };

denops/@denops-private/host/vim_test.ts

@@ -19,6 +19,7 @@ Deno.test("Vim", async (t) => {
         bind: () => unimplemented(),
         load: () => unimplemented(),
         reload: () => unimplemented(),
+        interrupt: () => unimplemented(),
         dispatch: () => unimplemented(),
         dispatchAsync: () => unimplemented(),
       };

denops/@denops-private/host_test.ts

@@ -12,6 +12,7 @@ Deno.test("invoke", async (t) => {
   const service: Omit<Service, "bind"> = {
     load: () => unimplemented(),
     reload: () => unimplemented(),
+    interrupt: () => unimplemented(),
     dispatch: () => unimplemented(),
     dispatchAsync: () => unimplemented(),
   };
@@ -46,6 +47,28 @@ Deno.test("invoke", async (t) => {
     });
   });
 
+  await t.step("calls 'interrupt'", async (t) => {
+    await t.step("ok", async () => {
+      using s = stub(service, "interrupt");
+      await invoke(service, "interrupt", []);
+      assertSpyCalls(s, 1);
+      assertSpyCall(s, 0, { args: [] });
+    });
+
+    await t.step("ok (with reason)", async () => {
+      using s = stub(service, "interrupt");
+      await invoke(service, "interrupt", ["reason"]);
+      assertSpyCalls(s, 1);
+      assertSpyCall(s, 0, { args: ["reason"] });
+    });
+
+    await t.step("invalid args", () => {
+      using s = stub(service, "interrupt");
+      assertThrows(() => invoke(service, "interrupt", ["a", "b"]), AssertError);
+      assertSpyCalls(s, 0);
+    });
+  });
+
   await t.step("calls 'dispatch'", async (t) => {
     await t.step("ok", async () => {
       using s = stub(service, "dispatch");

denops/@denops-private/service.ts

@@ -13,8 +13,9 @@ type Waiter = {
  * 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();
+  #interruptController = new AbortController();
+  #plugins = new Map<string, Plugin>();
+  #waiters = new Map<string, Waiter>();
   #meta: Meta;
   #host?: Host;
 
@@ -29,6 +30,10 @@ export class Service implements Disposable {
     return this.#waiters.get(name)!;
   }
 
+  get interrupted(): AbortSignal {
+    return this.#interruptController.signal;
+  }
+
   bind(host: Host): void {
     this.#host = host;
   }
@@ -77,6 +82,11 @@ export class Service implements Disposable {
     return this.#getWaiter(name).promise;
   }
 
+  interrupt(reason?: unknown): void {
+    this.#interruptController.abort(reason);
+    this.#interruptController = new AbortController();
+  }
+
   async #dispatch(name: string, fn: string, args: unknown[]): Promise<unknown> {
     const plugin = this.#plugins.get(name);
     if (!plugin) {

denops/@denops-private/service_test.ts

@@ -3,6 +3,7 @@ import {
   assertEquals,
   assertMatch,
   assertRejects,
+  assertThrows,
 } from "jsr:@std/[email protected]";
 import {
   assertSpyCall,
@@ -389,4 +390,24 @@ Deno.test("Service", async (t) => {
       });
     },
   );
+
+  await t.step(
+    "interrupt() sends interrupt signal to `interrupted` attribute",
+    () => {
+      const signal = service.interrupted;
+      signal.throwIfAborted(); // Should not throw
+      service.interrupt();
+      assertThrows(() => signal.throwIfAborted());
+    },
+  );
+
+  await t.step(
+    "interrupt() sends interrupt signal to `interrupted` attribute with reason",
+    () => {
+      const signal = service.interrupted;
+      signal.throwIfAborted(); // Should not throw
+      service.interrupt("test");
+      assertThrows(() => signal.throwIfAborted(), "test");
+    },
+  );
 });

doc/denops.txt

@@ -28,6 +28,23 @@ API Reference: https://deno.land/x/denops_std/mod.ts
 =============================================================================
 USAGE							*denops-usage*
 
+-----------------------------------------------------------------------------
+RECOMMENDED					*denops-recommended*
+
+Add the following recommended settings to your |vimrc| or |init.vim|:
+>
+	" Interrupt the process of plugins via <C-c>
+	noremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
+	inoremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
+	cnoremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
+
+	" Restart Denops server
+	command! DenopsRestart call denops#server#restart()
+
+	" Fix Deno module cache issue
+	command! DenopsFixCache call denops#cache#update(#{reload: v:true})
+<
+
 -----------------------------------------------------------------------------
 SHARED SERVER					*denops-shared-server*
 
@@ -199,6 +216,26 @@ denops#request_async({name}, {method}, {params}, {success}, {failure})
 	      \ { v -> s:success(v) },
 	      \ { e -> s:failure(e) },
 	      \)
+<
+						*denops#interrupt()*
+denops#interrupt([{reason}])
+	Interrupts the process of plugins. It is assumed to be used to
+	interrupt the process of plugins when the user presses a key or
+	issues a command.
+	{reason} is an optional string to describe the reason for the
+	interruption.
+	Note that the interruption is not guaranteed to be immediate.
+
+	Use the following mapping to interrupt the process of plugins:
+>
+	" For normal/visual/select mode
+	noremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
+
+	" For insert mode
+	inoremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
+
+	" For command mode
+	cnoremap <silent> <C-c> <Cmd>call denops#interrupt()<CR><C-c>
 <
 						*denops#cache#update()*
 denops#cache#update([{options}])