👍 Support denops.redraw() in batch

The `denops.redraw()` was introduced from denops v3.2.0

Author: lambdalisue

denops_std/batch/README.md

@@ -94,6 +94,11 @@ export async function main(denops: Denops): Promise<void> {
 }
 ```
 
+Note that `denops.redraw()` is executed only once after the batch is actually
+executed, no matter how many times it is called in the `batch()`. If the `force`
+option is specified even once, the last call will be the one with the force
+option specified.
+
 ### gather
 
 Use `gather()` to call multiple denops functions sequentially without overhead
@@ -138,3 +143,6 @@ 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.
+
+Note that `denops.redraw()` cannot be called within `gather()`. If it is called,
+an error is raised.

denops_std/batch/batch.ts

@@ -5,9 +5,12 @@ import type {
   Meta,
 } from "https://deno.land/x/denops_core@v3.2.0/mod.ts";
 
+type Redraw = undefined | boolean;
+
 class BatchHelper implements Denops {
   #denops: Denops;
   #calls: [string, ...unknown[]][];
+  #redraw: Redraw;
   #closed: boolean;
 
   constructor(denops: Denops) {
@@ -20,6 +23,10 @@ class BatchHelper implements Denops {
     return helper.#calls;
   }
 
+  static getRedraw(helper: BatchHelper): Redraw {
+    return helper.#redraw;
+  }
+
   static close(helper: BatchHelper): void {
     helper.#closed = true;
   }
@@ -44,6 +51,12 @@ class BatchHelper implements Denops {
     this.#denops.dispatcher = dispatcher;
   }
 
+  redraw(force?: boolean): Promise<void> {
+    // Prefer 'force' if the method is called multiple times
+    this.#redraw = !!this.#redraw || !!force;
+    return Promise.resolve();
+  }
+
   call(fn: string, ...args: unknown[]): Promise<unknown> {
     if (this.#closed) {
       return this.#denops.call(fn, ...args);
@@ -96,6 +109,10 @@ export async function batch(
   }
   const calls = BatchHelper.getCalls(helper);
   await denops.batch(...calls);
+  const redraw = BatchHelper.getRedraw(helper);
+  if (redraw != null) {
+    await denops.redraw(redraw);
+  }
 }
 
 export type { BatchHelper };

denops_std/batch/batch_test.ts

@@ -1,4 +1,9 @@
 import { assertEquals } from "https://deno.land/std@0.159.0/testing/asserts.ts";
+import {
+  assertSpyCall,
+  assertSpyCalls,
+  spy,
+} from "https://deno.land/std@0.159.0/testing/mock.ts";
 import { test } from "https://deno.land/x/denops_core@v3.2.0/test/mod.ts";
 import { batch, BatchHelper } from "./batch.ts";
 
@@ -161,3 +166,87 @@ test({
     ]);
   },
 });
+test({
+  mode: "any",
+  name:
+    "batch() invokes 'redraw()' only once after the batch is actually executed.",
+  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>]",
+    );
+    const redrawSpy = spy(denops, "redraw");
+    try {
+      await batch(denops, async (denops) => {
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 1"),
+          undefined,
+        );
+        await denops.redraw();
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 2"),
+          undefined,
+        );
+        await denops.redraw();
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 3"),
+          undefined,
+        );
+        await denops.redraw();
+      });
+    } finally {
+      redrawSpy.restore();
+    }
+    assertEquals(await denops.eval("g:denops_batch_test") as string[], [
+      "1",
+      "2",
+      "3",
+    ]);
+    assertSpyCalls(redrawSpy, 1);
+    assertSpyCall(redrawSpy, 0, {
+      args: [false],
+    });
+  },
+});
+test({
+  mode: "any",
+  name:
+    "batch() invokes 'redraw(true)' only once after the batch is actually executed.",
+  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>]",
+    );
+    const redrawSpy = spy(denops, "redraw");
+    try {
+      await batch(denops, async (denops) => {
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 1"),
+          undefined,
+        );
+        await denops.redraw();
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 2"),
+          undefined,
+        );
+        await denops.redraw(true);
+        assertEquals(
+          await denops.call("execute", "DenopsBatchTest 3"),
+          undefined,
+        );
+        await denops.redraw();
+      });
+    } finally {
+      redrawSpy.restore();
+    }
+    assertEquals(await denops.eval("g:denops_batch_test") as string[], [
+      "1",
+      "2",
+      "3",
+    ]);
+    assertSpyCalls(redrawSpy, 1);
+    assertSpyCall(redrawSpy, 0, {
+      args: [true],
+    });
+  },
+});

denops_std/batch/gather.ts

@@ -44,6 +44,10 @@ class GatherHelper implements Denops {
     this.#denops.dispatcher = dispatcher;
   }
 
+  redraw(_force?: boolean): Promise<void> {
+    throw new Error("The 'redraw' method is not available on GatherHelper.");
+  }
+
   call(fn: string, ...args: unknown[]): Promise<unknown> {
     if (this.#closed) {
       throw new Error(

denops_std/batch/gather_test.ts

@@ -93,3 +93,18 @@ test({
     );
   },
 });
+test({
+  mode: "any",
+  name: "gather() throws an error when 'denops.redraw()' is called.",
+  fn: async (denops) => {
+    await assertRejects(
+      async () => {
+        await gather(denops, async (denops) => {
+          await denops.redraw();
+        });
+      },
+      "method is not available",
+    );
+  },
+  prelude: ["let g:denops#enable_workaround_vim_before_8_2_3081 = 1"],
+});