@tui-sandbox/library 7.2.1 → 7.3.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [7.3.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v7.2.1...library-v7.3.0) (2024-11-30)
+
+
+### Features
+
+* can run a headless neovim ex-command before tests ([700d83c](https://github.com/mikavilpas/tui-sandbox/commit/700d83c6b19875e946b38ef382b9eb48e22cb5f6))
+
 ## [7.2.1](https://github.com/mikavilpas/tui-sandbox/compare/library-v7.2.0...library-v7.2.1) (2024-11-28)
 
 

package/dist/src/scripts/tui.js

@@ -1,26 +1,111 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import assert from "node:assert";
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { createCypressSupportFile } from "../server/cypress-support/createCypressSupportFile.js";
 import { startTestServer, updateTestdirectorySchemaFile } from "../server/index.js";
+import { NeovimApplication } from "../server/neovim/NeovimApplication.js";
+import { prepareNewTestDirectory } from "../server/neovim/index.js";
 //
 // This is the main entrypoint to tui-sandbox
 //
-// the arguments passed to this script start at index 2
-const args = process.argv.slice(2);
-if (args[0] !== "start") {
-    throw new Error(`Usage: tui start`);
-}
 const outputFileName = "MyTestDirectory.ts";
 /** The cwd in the user's directory when they are running this script. Not the
  * cwd of the script itself. */
 const cwd = process.cwd();
+const config = {
+    testEnvironmentPath: path.join(cwd, "test-environment/"),
+    outputFilePath: path.join(cwd, outputFileName),
+};
+// the arguments passed to this script start at index 2
+const args = process.argv.slice(2);
+if (args[0] === "neovim") {
+    if (!(args[1] === "exec" && args.length === 3)) {
+        showUsageAndExit();
+    }
+    const command = args[2];
+    assert(command, "No command provided");
+    {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            // automatically dispose of the neovim instance when done
+            const app = __addDisposableResource(env_1, new NeovimApplication(config.testEnvironmentPath), true);
+            app.events.on("stdout", data => {
+                console.log(`  neovim output: ${data}`);
+            });
+            const testDirectory = await prepareNewTestDirectory(config);
+            await app.startNextAndKillCurrent(testDirectory, { filename: "empty.txt", headlessCmd: command }, { cols: 80, rows: 24 });
+            await app.application.untilExit();
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    process.exit(0);
+}
+if (args[0] !== "start") {
+    showUsageAndExit();
+}
 console.log(`🚀 Starting test server in ${cwd} - this should be the root of your integration-tests directory 🤞🏻`);
 await stat(path.join(cwd, outputFileName));
 try {
-    const config = {
-        testEnvironmentPath: path.join(cwd, "test-environment/"),
-        outputFilePath: path.join(cwd, outputFileName),
-    };
     await createCypressSupportFile({
         cypressSupportDirectoryPath: path.join(cwd, "cypress", "support"),
         supportFileName: "tui-sandbox.ts",
@@ -31,3 +116,12 @@ try {
 catch (e) {
     console.error(e);
 }
+function showUsageAndExit() {
+    console.log([
+        //
+        `Usage (pick one):`,
+        `    tui start`,
+        `    tui neovim exec '<ex-command>'`,
+    ].join("\n"));
+    process.exit(1);
+}

package/dist/src/server/neovim/NeovimApplication.d.ts

@@ -3,12 +3,14 @@ import type { NeovimClient as NeovimApiClient } from "neovim";
 import type { TestDirectory } from "../types.js";
 import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication.js";
 import type { Lazy } from "../utilities/Lazy.js";
-export type StdoutMessage = "stdout";
+export type StdoutOrStderrMessage = "stdout";
 export type StartNeovimGenericArguments = {
     filename: string | {
         openInVerticalSplits: string[];
     };
     startupScriptModifications?: string[];
+    /** Executes the given command with --headless -c <command> -c qa */
+    headlessCmd?: string;
     /** Additions to the environment variables for the Neovim process. These
      * override any already existing environment variables. */
     additionalEnvironmentVariables?: Record<string, string> | undefined;

package/dist/src/server/neovim/NeovimApplication.js

@@ -48,6 +48,12 @@ export class NeovimApplication {
                 neovimArguments.push(filePath);
             }
         }
+        if (startArgs.headlessCmd) {
+            // NOTE: update the doc comment above if this changes
+            neovimArguments.push("--headless");
+            neovimArguments.push("-c", startArgs.headlessCmd);
+            neovimArguments.push("-c", "qa");
+        }
         const id = Math.random().toString().slice(2, 8);
         const socketPath = `${tmpdir()}/tui-sandbox-nvim-socket-${id}`;
         neovimArguments.push("--listen", socketPath);

package/dist/src/server/neovim/NeovimJavascriptApiClient.js

@@ -8,11 +8,11 @@ export function connectNeovimApi(socketPath) {
         for (let i = 0; i < 100; i++) {
             try {
                 await access(socketPath);
-                console.log(`socket file ${socketPath} created after at attempt ${i + 1}`);
+                // console.log(`socket file ${socketPath} created after at attempt ${i + 1}`)
                 break;
             }
             catch (e) {
-                console.log(`polling for socket file ${socketPath} to be created (attempt ${i + 1})`);
+                // console.log(`polling for socket file ${socketPath} to be created (attempt ${i + 1})`)
                 await new Promise(resolve => setTimeout(resolve, 100));
             }
         }

package/dist/src/server/neovim/index.d.ts

@@ -2,12 +2,15 @@ import "core-js/proposals/async-explicit-resource-management.js";
 import type { BlockingCommandInput, ExCommandInput, LuaCodeInput } from "../server.js";
 import type { BlockingShellCommandOutput, RunExCommandOutput, RunLuaCodeOutput, StartNeovimGenericArguments, TestDirectory } from "../types.js";
 import type { TestServerConfig } from "../updateTestdirectorySchemaFile.js";
+import { Lazy } from "../utilities/Lazy.js";
 import type { TabId } from "../utilities/tabId.js";
 import type { TerminalDimensions } from "./NeovimApplication.js";
-export declare function onStdout(options: {
+export declare const resources: Lazy<AsyncDisposableStack>;
+export declare function initializeStdout(options: {
     client: TabId;
 }, signal: AbortSignal | undefined, testEnvironmentPath: string): Promise<AsyncGenerator<string, void, unknown>>;
 export declare function start(options: StartNeovimGenericArguments, terminalDimensions: TerminalDimensions, tabId: TabId, config: TestServerConfig): Promise<TestDirectory>;
+export declare function prepareNewTestDirectory(config: TestServerConfig): Promise<TestDirectory>;
 export declare function sendStdin(options: {
     tabId: TabId;
     data: string;

package/dist/src/server/neovim/index.js

@@ -3,14 +3,21 @@ import { exec } from "child_process";
 import "core-js/proposals/async-explicit-resource-management.js";
 import util from "util";
 import { convertEventEmitterToAsyncGenerator } from "../utilities/generator.js";
+import { Lazy } from "../utilities/Lazy.js";
 import { createTempDir, removeTestDirectories } from "./environment/createTempDir.js";
 import { NeovimApplication } from "./NeovimApplication.js";
 const neovims = new Map();
-export async function onStdout(options, signal, testEnvironmentPath) {
+export const resources = new Lazy(() => {
+    return new AsyncDisposableStack();
+});
+export async function initializeStdout(options, signal, testEnvironmentPath) {
     const tabId = options.client.tabId;
     const neovim = neovims.get(tabId) ?? new NeovimApplication(testEnvironmentPath);
     if (neovims.get(tabId) === undefined) {
         neovims.set(tabId, neovim);
+        resources.get().adopt(neovim, async (n) => {
+            await n[Symbol.asyncDispose]();
+        });
     }
     const stdout = convertEventEmitterToAsyncGenerator(neovim.events, "stdout");
     if (signal) {
@@ -25,9 +32,13 @@ export async function onStdout(options, signal, testEnvironmentPath) {
 export async function start(options, terminalDimensions, tabId, config) {
     const neovim = neovims.get(tabId.tabId);
     assert(neovim, `Neovim instance not found for client id ${tabId.tabId}`);
+    const testDirectory = await prepareNewTestDirectory(config);
+    await neovim.startNextAndKillCurrent(testDirectory, options, terminalDimensions);
+    return testDirectory;
+}
+export async function prepareNewTestDirectory(config) {
     await removeTestDirectories(config.testEnvironmentPath);
     const testDirectory = await createTempDir(config);
-    await neovim.startNextAndKillCurrent(testDirectory, options, terminalDimensions);
     return testDirectory;
 }
 export async function sendStdin(options) {

package/dist/src/server/server.js

@@ -48,7 +48,7 @@ export async function createAppRouter(config) {
                 return neovim.start(options.input.startNeovimArguments, options.input.startNeovimArguments.terminalDimensions, options.input.tabId, config);
             }),
             onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
-                return neovim.onStdout(options.input, options.signal, config.testEnvironmentPath);
+                return neovim.initializeStdout(options.input, options.signal, config.testEnvironmentPath);
             }),
             sendStdin: trpc.procedure.input(z.object({ tabId: tabIdSchema, data: z.string() })).mutation(options => {
                 return neovim.sendStdin(options.input);

package/dist/src/server/utilities/DisposableSingleApplication.d.ts

@@ -1,5 +1,5 @@
-import type { TerminalApplication } from "./TerminalApplication.js";
-export type StartableApplication = Pick<TerminalApplication, "write" | "processId" | "killAndWait">;
+import type { ExitInfo, TerminalApplication } from "./TerminalApplication.js";
+export type StartableApplication = Pick<TerminalApplication, "write" | "processId" | "killAndWait" | "untilExit">;
 /** A testable application that can be started, killed, and given input. For a
  * single instance of this interface, only a single instance can be running at
  * a time.
@@ -7,6 +7,7 @@ export type StartableApplication = Pick<TerminalApplication, "write" | "processI
 export declare class DisposableSingleApplication implements AsyncDisposable {
     protected application: StartableApplication | undefined;
     startNextAndKillCurrent(startNext: () => Promise<StartableApplication>): Promise<void>;
+    untilExit(): Promise<ExitInfo>;
     write(input: string): Promise<void>;
     processId(): number | undefined;
     /** Kill the current application if it exists. */

package/dist/src/server/utilities/DisposableSingleApplication.js

@@ -9,6 +9,10 @@ export class DisposableSingleApplication {
         await this[Symbol.asyncDispose]();
         this.application = await startNext();
     }
+    async untilExit() {
+        assert(this.application, "The application not started yet. It makes no sense to wait for it to exit, so this looks like a bug.");
+        return this.application.untilExit;
+    }
     async write(input) {
         assert(this.application, "The application not started yet. It makes no sense to write to it, so this looks like a bug.");
         this.application.write(input);

package/dist/src/server/utilities/DisposableSingleApplication.test.js

@@ -9,6 +9,7 @@ const fakeApp = {
     processId: 123,
     write: vi.fn(),
     killAndWait: vi.fn(),
+    untilExit: Promise.resolve({ exitCode: 0, signal: undefined }),
 };
 describe("DisposableSingleApplication", () => {
     it("has no application when created", () => {
@@ -34,6 +35,23 @@ describe("DisposableSingleApplication", () => {
         const app = new TestDisposableSingleApplication();
         await expect(app.write("hello")).rejects.toThrowErrorMatchingInlineSnapshot(`[AssertionError: The application not started yet. It makes no sense to write to it, so this looks like a bug.]`);
     });
+    describe("untilExit allows waiting for the application to exit", () => {
+        it("successful exit works", async () => {
+            const app = new TestDisposableSingleApplication();
+            await app.startNextAndKillCurrent(async () => fakeApp);
+            fakeApp.untilExit = Promise.resolve({ exitCode: 1, signal: 9 });
+            await expect(app.untilExit()).resolves.toStrictEqual({
+                exitCode: 1,
+                signal: 9,
+            });
+        });
+        it("when the application throws an error, the error is propagated", async () => {
+            const app = new TestDisposableSingleApplication();
+            await app.startNextAndKillCurrent(async () => fakeApp);
+            fakeApp.untilExit = Promise.reject(new Error("fake error"));
+            await expect(app.untilExit()).rejects.toThrowError(new Error("fake error"));
+        });
+    });
     describe("disposing", () => {
         it("disposes the application when disposed", async () => {
             // it's important to make sure there are no dangling applications when

package/dist/src/server/utilities/TerminalApplication.d.ts

@@ -1,9 +1,14 @@
 import type winston from "winston";
 import type { ITerminalDimensions } from "@xterm/addon-fit";
 import type { StartableApplication } from "./DisposableSingleApplication.js";
+export type ExitInfo = {
+    exitCode: number;
+    signal: number | undefined;
+};
 export declare class TerminalApplication implements StartableApplication {
     private readonly subProcess;
     readonly onStdoutOrStderr: (data: string) => void;
+    readonly untilExit: Promise<ExitInfo>;
     readonly processId: number;
     readonly logger: winston.Logger;
     private constructor();

package/dist/src/server/utilities/TerminalApplication.js

@@ -5,11 +5,13 @@ import pty from "node-pty";
 export class TerminalApplication {
     subProcess;
     onStdoutOrStderr;
+    untilExit;
     processId;
     logger;
-    constructor(subProcess, onStdoutOrStderr) {
+    constructor(subProcess, onStdoutOrStderr, untilExit) {
         this.subProcess = subProcess;
         this.onStdoutOrStderr = onStdoutOrStderr;
+        this.untilExit = untilExit;
         this.processId = subProcess.pid;
         this.logger = createLogger({
             transports: [new transports.Console()],
@@ -32,11 +34,20 @@ export class TerminalApplication {
             cols: dimensions.cols,
             rows: dimensions.rows,
         });
+        ptyProcess.onExit(({ exitCode, signal }) => {
+            console.log(`Child process exited with code ${exitCode} and signal ${signal}`);
+        });
         const processId = ptyProcess.pid;
         if (!processId) {
             throw new Error("Failed to spawn child process");
         }
-        return new TerminalApplication(ptyProcess, onStdoutOrStderr);
+        const untilExit = new Promise(resolve => {
+            ptyProcess.onExit(({ exitCode, signal }) => {
+                // console.log(`Child process ${processId} exited with code ${exitCode} and signal ${signal}`)
+                resolve({ exitCode, signal });
+            });
+        });
+        return new TerminalApplication(ptyProcess, onStdoutOrStderr, untilExit);
     }
     /** Write to the terminal's stdin. */
     write(data) {