@tui-sandbox/library 7.5.6 → 7.7.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [7.7.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v7.6.0...library-v7.7.0) (2025-01-12)
+
+
+### Features
+
+* create config-modifications directory if it doesn't exist ([1688f88](https://github.com/mikavilpas/tui-sandbox/commit/1688f88db821c73b499c1b0cb2f2ebe0fe221741))
+
+## [7.6.0](https://github.com/mikavilpas/tui-sandbox/compare/library-v7.5.6...library-v7.6.0) (2025-01-11)
+
+
+### Features
+
+* can run a prepare script before starting the tests ([#225](https://github.com/mikavilpas/tui-sandbox/issues/225)) ([53d1a32](https://github.com/mikavilpas/tui-sandbox/commit/53d1a32ff292f9a931a90fddceb5ec36a8dad84a))
+
 ## [7.5.6](https://github.com/mikavilpas/tui-sandbox/compare/library-v7.5.5...library-v7.5.6) (2025-01-09)
 
 

package/dist/src/server/cypress-support/contents.js

@@ -34,6 +34,8 @@ declare global {
   }
 }
 
+/** Arguments for starting the neovim server. They are built based on your test
+ * environment in a type safe manner. */
 type MyStartNeovimServerArguments = OverrideProperties<
   StartNeovimGenericArguments,
   {

package/dist/src/server/cypress-support/createCypressSupportFile.js

@@ -1,4 +1,5 @@
 import { readFileSync, writeFileSync } from "fs";
+import { mkdir, stat } from "fs/promises";
 import path from "path";
 import { createCypressSupportFileContents } from "./contents.js";
 /**
@@ -7,6 +8,15 @@ import { createCypressSupportFileContents } from "./contents.js";
  * tui-sandbox version.
  */
 export async function createCypressSupportFile({ cypressSupportDirectoryPath, supportFileName, }) {
+    // create config-modifications directory if it doesn't exist
+    const configModificationsDirectoryPath = path.join(cypressSupportDirectoryPath, "config-modifications");
+    try {
+        await stat(configModificationsDirectoryPath);
+    }
+    catch (error) {
+        console.log(`Creating config-modifications directory at ${configModificationsDirectoryPath}. You can put Neovim startup scripts into this directory, and load them when starting your Neovim test.`);
+        await mkdir(configModificationsDirectoryPath);
+    }
     const text = await createCypressSupportFileContents();
     let oldSchema = "";
     const outputFilePath = path.join(cypressSupportDirectoryPath, supportFileName);

package/dist/src/server/cypress-support/createCypressSupportFile.test.js

@@ -1,12 +1,16 @@
 import { readFileSync, writeFileSync } from "fs";
+import { mkdir, stat } from "fs/promises";
 import { createCypressSupportFileContents } from "./contents.js";
 import { createCypressSupportFile } from "./createCypressSupportFile.js";
 vi.mock("fs");
+vi.mock("fs/promises");
 vi.mock("./contents.ts");
 const mocked = {
     readFileSync: vi.mocked(readFileSync),
     writeFileSync: vi.mocked(writeFileSync),
     createCypressSupportFileContents: vi.mocked(createCypressSupportFileContents),
+    mkdir: vi.mocked(mkdir),
+    stat: vi.mocked(stat),
 };
 describe("createCypressSupportFileContents", () => {
     it("should update the file if the schema has changed", async () => {
@@ -32,4 +36,21 @@ describe("createCypressSupportFileContents", () => {
         });
         expect(result).toBe("did-nothing");
     });
+    it("should create the config-modifications directory if it does not exist", async () => {
+        // This directory is required to exist so that a type safe schema of the
+        // neovimArguments can be built and used.
+        mocked.readFileSync.mockImplementationOnce(() => "");
+        mocked.writeFileSync.mockImplementationOnce(() => {
+            //
+        });
+        mocked.createCypressSupportFileContents.mockImplementationOnce(async () => "contents");
+        mocked.stat.mockRejectedValueOnce(new Error("ENOENT"));
+        const result = await createCypressSupportFile({
+            cypressSupportDirectoryPath: "cypress/support",
+            supportFileName: "tui-sandbox.ts",
+        });
+        expect(result).toBe("updated");
+        expect(mocked.mkdir).toHaveBeenCalledWith("cypress/support/config-modifications");
+        expect(mocked.mkdir).toHaveBeenCalledTimes(1);
+    });
 });

package/dist/src/server/dirtree/index.test.js

@@ -52,6 +52,12 @@ describe("dirtree", () => {
                     extension: z.literal("lua"),
                     stem: z.literal("init."),
                   }),
+                  "prepare.lua": z.object({
+                    name: z.literal("prepare.lua"),
+                    type: z.literal("file"),
+                    extension: z.literal("lua"),
+                    stem: z.literal("prepare."),
+                  }),
                 }),
               }),
             }),
@@ -104,6 +110,24 @@ describe("dirtree", () => {
             extension: z.literal("txt"),
             stem: z.literal("initial-file."),
           }),
+          "lua-project": z.object({
+            name: z.literal("lua-project/"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "config.lua": z.object({
+                name: z.literal("config.lua"),
+                type: z.literal("file"),
+                extension: z.literal("lua"),
+                stem: z.literal("config."),
+              }),
+              "init.lua": z.object({
+                name: z.literal("init.lua"),
+                type: z.literal("file"),
+                extension: z.literal("lua"),
+                stem: z.literal("init."),
+              }),
+            }),
+          }),
           "other-subdirectory": z.object({
             name: z.literal("other-subdirectory/"),
             type: z.literal("directory"),
@@ -169,6 +193,7 @@ describe("dirtree", () => {
       export const testDirectoryFiles = z.enum([
         ".config/.gitkeep",
         ".config/nvim/init.lua",
+        ".config/nvim/prepare.lua",
         ".config/nvim",
         ".config",
         "config-modifications/add_command_to_count_open_buffers.lua",
@@ -179,6 +204,9 @@ describe("dirtree", () => {
         "dir with spaces",
         "file.txt",
         "initial-file.txt",
+        "lua-project/config.lua",
+        "lua-project/init.lua",
+        "lua-project",
         "other-subdirectory/other-sub-file.txt",
         "other-subdirectory",
         "routes/posts.$postId/adjacent-file.txt",

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

@@ -2,10 +2,9 @@ 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 { DirectoriesConfig } from "../updateTestdirectorySchemaFile.js";
-import { Lazy } from "../utilities/Lazy.js";
 import type { TabId } from "../utilities/tabId.js";
 import type { TerminalDimensions } from "./NeovimApplication.js";
-export declare const resources: Lazy<AsyncDisposableStack>;
+export declare function installDependencies(testEnvironmentPath: string, config: DirectoriesConfig): Promise<void>;
 export declare function initializeStdout(options: {
     client: TabId;
 }, signal: AbortSignal | undefined, testEnvironmentPath: string): Promise<AsyncGenerator<string, void, unknown>>;

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

@@ -1,15 +1,99 @@
+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 "assert";
 import { exec } from "child_process";
 import "core-js/proposals/async-explicit-resource-management.js";
+import { access } from "fs/promises";
+import path from "path";
 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 const resources = new Lazy(() => {
+const resources = new Lazy(() => {
     return new AsyncDisposableStack();
 });
+export async function installDependencies(testEnvironmentPath, config) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const app = __addDisposableResource(env_1, new NeovimApplication(testEnvironmentPath), true);
+        const testDirectory = await prepareNewTestDirectory(config);
+        const prepareFilePath = path.join(testDirectory.rootPathAbsolute, ".config", "nvim", "prepare.lua");
+        try {
+            await access(prepareFilePath);
+        }
+        catch (e) {
+            console.log(`Neovim prepareFilePath does not exist: ${prepareFilePath}. If you want to run a prepare script before starting the tests, create it.`);
+            return;
+        }
+        console.log(`🚀 Running Neovim prepareFilePath ${prepareFilePath}...`);
+        app.events.on("stdout", data => {
+            console.log(`  neovim output: ${data}`);
+        });
+        await app.startNextAndKillCurrent(testDirectory, { filename: "empty.txt", headlessCmd: `lua dofile("${prepareFilePath}")` }, { 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;
+    }
+}
 export async function initializeStdout(options, signal, testEnvironmentPath) {
     const tabId = options.client.tabId;
     const neovim = neovims.get(tabId) ?? new NeovimApplication(testEnvironmentPath);

package/dist/src/server/server.js

@@ -75,6 +75,10 @@ export async function startTestServer(config) {
         port: config.port,
     });
     const appRouter = await createAppRouter(config.directories);
-    await testServer.startAndRun(appRouter);
+    await Promise.all([
+        // NOTE right now Neovim is always initialized
+        neovim.installDependencies(config.directories.testEnvironmentPath, config.directories),
+        testServer.startAndRun(appRouter),
+    ]);
     return testServer;
 }

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

@@ -0,0 +1 @@
+export declare function timeout(ms: number): Promise<unknown>;

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

@@ -0,0 +1,3 @@
+export function timeout(ms) {
+    return new Promise((_, reject) => setTimeout(reject, ms));
+}