ember.nvp 0.5.0 → 0.7.0

package/test/ember.nvp/stage.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from "vitest";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+
+import { Stage } from "ember.nvp";
+import { mktemp } from "#test-helpers";
+
+async function makeTargetProject() {
+  const target = join(await mktemp("stage-target"), "my-app");
+
+  await mkdir(join(target, "app"), { recursive: true });
+  await mkdir(join(target, "node_modules/some-dep"), { recursive: true });
+  await writeFile(join(target, "package.json"), `{ "name": "my-app" }`);
+  await writeFile(join(target, "app/app.js"), `export default class App {}`);
+  await writeFile(join(target, "tsconfig.json"), `{}`);
+  await writeFile(join(target, "node_modules/some-dep/index.js"), `module.exports = 1;`);
+
+  return target;
+}
+
+describe("Stage", () => {
+  describe("a new project (target does not exist)", () => {
+    it("stages writes without touching the target, then commits them", async () => {
+      const target = join(await mktemp("stage-new"), "my-app");
+      const stage = await Stage.create(target);
+
+      expect(stage.isNew).toBe(true);
+
+      await mkdir(join(stage.directory, "app"), { recursive: true });
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "my-app" }`);
+      await writeFile(join(stage.directory, "app/app.js"), `export default class App {}`);
+
+      expect(existsSync(target), "target is untouched while staged").toBe(false);
+
+      const changes = await stage.changes();
+
+      expect(changes).toEqual([
+        { path: "app/app.js", status: "added" },
+        { path: "package.json", status: "added" },
+      ]);
+
+      await stage.commit();
+
+      expect(await readFile(join(target, "package.json"), "utf-8")).toBe(`{ "name": "my-app" }`);
+      expect(existsSync(join(target, "app/app.js"))).toBe(true);
+      expect(existsSync(stage.directory), "stage is cleaned up after commit").toBe(false);
+    });
+
+    it("carries a git repo initialized in the stage over to the target", async () => {
+      const target = join(await mktemp("stage-git"), "my-app");
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, "readme.md"), `hi`);
+      execSync("git init --initial-branch=main", { cwd: stage.directory, stdio: "pipe" });
+
+      await stage.commit();
+
+      expect(existsSync(join(target, ".git"))).toBe(true);
+      expect(existsSync(join(target, "readme.md"))).toBe(true);
+    });
+  });
+
+  describe("an existing project (seeded stage)", () => {
+    it("seeds the target's files, excluding node_modules and .git", async () => {
+      const target = await makeTargetProject();
+      execSync("git init --initial-branch=main", { cwd: target, stdio: "pipe" });
+
+      const stage = await Stage.create(target);
+
+      expect(stage.isNew).toBe(false);
+      expect(existsSync(join(stage.directory, "package.json"))).toBe(true);
+      expect(existsSync(join(stage.directory, "app/app.js"))).toBe(true);
+      expect(existsSync(join(stage.directory, "node_modules"))).toBe(false);
+      expect(existsSync(join(stage.directory, ".git"))).toBe(false);
+
+      await stage.discard();
+    });
+
+    it("detects added, modified, and deleted files", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, ".prettierrc.js"), `export default {};`);
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "renamed" }`);
+      await rm(join(stage.directory, "tsconfig.json"));
+
+      const changes = await stage.changes();
+
+      expect(changes).toEqual([
+        { path: ".prettierrc.js", status: "added" },
+        { path: "package.json", status: "modified" },
+        { path: "tsconfig.json", status: "deleted" },
+      ]);
+
+      await stage.discard();
+    });
+
+    it("commit only touches changed paths, preserving node_modules and unrelated files", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "renamed" }`);
+      await rm(join(stage.directory, "tsconfig.json"));
+
+      await stage.commit();
+
+      expect(await readFile(join(target, "package.json"), "utf-8")).toBe(`{ "name": "renamed" }`);
+      expect(
+        existsSync(join(target, "tsconfig.json")),
+        "deleted in stage -> deleted in target",
+      ).toBe(false);
+      expect(existsSync(join(target, "app/app.js")), "unchanged files are untouched").toBe(true);
+      expect(
+        existsSync(join(target, "node_modules/some-dep/index.js")),
+        "node_modules survives commit",
+      ).toBe(true);
+    });
+
+    it("commit applies only the given subset of changes", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, ".prettierrc.js"), `export default {};`);
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "renamed" }`);
+      await rm(join(stage.directory, "tsconfig.json"));
+
+      const changes = await stage.changes();
+      const accepted = changes.filter((change) => change.path !== "package.json");
+
+      await stage.commit(accepted);
+
+      expect(existsSync(join(target, ".prettierrc.js")), "accepted addition is written").toBe(true);
+      expect(existsSync(join(target, "tsconfig.json")), "accepted deletion is applied").toBe(false);
+      expect(
+        await readFile(join(target, "package.json"), "utf-8"),
+        "rejected change is not applied",
+      ).toBe(`{ "name": "my-app" }`);
+    });
+
+    it("discard leaves the target exactly as it was", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "renamed" }`);
+
+      await stage.discard();
+
+      expect(await readFile(join(target, "package.json"), "utf-8")).toBe(`{ "name": "my-app" }`);
+      expect(existsSync(stage.directory)).toBe(false);
+    });
+
+    it("reports no changes when nothing was modified", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      expect(await stage.changes()).toEqual([]);
+
+      await stage.discard();
+    });
+  });
+
+  describe("diff", () => {
+    it("renders a unified diff for added, modified, and deleted files", async () => {
+      const target = await makeTargetProject();
+      const stage = await Stage.create(target);
+
+      await writeFile(join(stage.directory, ".prettierrc.js"), `export default {};`);
+      await writeFile(join(stage.directory, "package.json"), `{ "name": "renamed" }`);
+      await rm(join(stage.directory, "tsconfig.json"));
+
+      const diff = await stage.diff();
+
+      expect(diff).toContain(`+++ b/.prettierrc.js`);
+      expect(diff).toContain(`+export default {};`);
+
+      expect(diff).toContain(`--- a/package.json`);
+      expect(diff).toContain(`-{ "name": "my-app" }`);
+      expect(diff).toContain(`+{ "name": "renamed" }`);
+
+      expect(diff).toContain(`--- a/tsconfig.json`);
+      expect(diff).toContain(`+++ /dev/null`);
+
+      await stage.discard();
+    });
+  });
+});

package/test/test-helpers/permutate.test.ts

@@ -51,6 +51,23 @@ describe("permutate", () => {
     expect(hasOneEslint).toBe(true);
   });
 
+  it("enforces mutual exclusivity for testing layers", () => {
+    const result = permutate(["qunit", "vitest", "other"]);
+
+    for (const permutation of result) {
+      const testingCount = permutation.filter(
+        (item) => item === "qunit" || item === "vitest",
+      ).length;
+      expect(testingCount).toBeLessThanOrEqual(1);
+    }
+
+    const hasQunit = result.some((perm) => perm.includes("qunit"));
+    const hasVitest = result.some((perm) => perm.includes("vitest"));
+
+    expect(hasQunit).toBe(true);
+    expect(hasVitest).toBe(true);
+  });
+
   it("generates valid permutations with mixed items", () => {
     const result = permutate(["a", "eslint-foo", "eslint-bar", "b"]);
 

package/test/test-helpers.ts

@@ -16,10 +16,22 @@ export const bases = [minimalApp, minimalAddon];
 
 export const layers = await discoverLayers();
 
+/**
+ * Layers in the same group are alternatives to each other (one eslint
+ * config, one test framework): selecting two of them would produce a
+ * broken project, so permutations never combine them.
+ */
+function exclusivityGroup(name: string): string | undefined {
+  if (name.startsWith("eslint-")) return "eslint";
+  if (name === "qunit" || name === "vitest") return "testing";
+
+  return undefined;
+}
+
 export function permutate(toPermutate: string[]): string[][] {
   const out: string[][] = [];
 
-  function backtrack(startIndex: number, prefix: string[], hasEslint: boolean) {
+  function backtrack(startIndex: number, prefix: string[], usedGroups: Set<string>) {
     if (prefix.length > 0) out.push(prefix.slice());
 
     for (let i = startIndex; i < toPermutate.length; i++) {
@@ -34,19 +46,20 @@ export function permutate(toPermutate: string[]): string[][] {
       // (silly TS not understanding loop bounds)
       if (!option) continue;
 
-      const isEslint = option.startsWith("eslint-");
+      const group = exclusivityGroup(option);
 
-      // Skip this option if it's an eslint entry and we already have one
-      // (enforce mutual exclusivity for eslint-prefixed entries)
-      if (isEslint && hasEslint) continue;
+      // Skip this option if we already have one from its exclusivity group
+      if (group && usedGroups.has(group)) continue;
 
+      if (group) usedGroups.add(group);
       prefix.push(option);
-      backtrack(i + 1, prefix, hasEslint || isEslint);
+      backtrack(i + 1, prefix, usedGroups);
       prefix.pop();
+      if (group) usedGroups.delete(group);
     }
   }
 
-  backtrack(0, [], false);
+  backtrack(0, [], new Set());
   return out;
 }
 

package/tsconfig.json

@@ -10,6 +10,7 @@
     "dist",
     "packages",
     "src/**/layers/*/files/**",
+    "src/**/layers/*/library-files/**",
     "src/**/bases/*/files/**",
     "my-app"
   ]

package/packages/vite/src/maybe-babel.ts

@@ -1,219 +0,0 @@
-/**
- * Reasons we have to have babel
- * - decorators
- * - ember-concurrency
- * - scoped-css
- * - template compilation optimization
- */
-import { extensions } from "@embroider/vite";
-import { babel } from "@rollup/plugin-babel";
-import { join, resolve } from "node:path";
-import { parse as oxcParse } from "oxc-parser";
-import { transform } from "oxc-transform";
-import { walk } from "zimmerframe";
-
-/**
- * if a file imports any of these, it must be optimize
- */
-const babelTemplateImports = new Set([
-  // Templates
-  "@ember/template-compiler",
-  "@ember/template-compilation",
-  "ember-cli-htmlbars",
-  "ember-cli-htmlbars-inline-precompile",
-  "htmlbars-inline-precompile",
-]);
-
-const babelMacroImports = new Set([
-  // Macros
-  "@embroider/macros",
-  "@glimmer/env",
-  "@ember/application/deprecations",
-  // Macros only needed in prod
-  "@ember/debug",
-]); // Babel plugins required from libraries
-const babelOtherImports = new Set([
-  "ember-concurrency",
-  "ember-scoped-css",
-  "ember-intl/helpers/format-message",
-]);
-
-const babelRequiredImports = [...babelTemplateImports, ...babelMacroImports, ...babelOtherImports];
-
-const counts = {
-  total: 0,
-  babel: 0,
-  why: {
-    decorators: 0,
-    formatMessage: 0,
-    imports: {
-      templates: 0,
-      macros: 0,
-      other: 0,
-    },
-    initializeRuntimeMacrosConfig: 0,
-  },
-};
-export function maybeBabel(options: { parallel?: boolean; configFile: string; env: any }) {
-  const { env, parallel, ...restOptions } = options;
-  const original = (() => {
-    const babelPath = resolve(join(process.cwd(), "./babel.config.js"));
-
-    return babel({
-      babelHelpers: "runtime",
-      extensions,
-      skipPreflightCheck: true,
-      ...restOptions,
-      configFile: babelPath,
-      parallel: parallel ?? true,
-    });
-  })();
-
-  /**
-   * In @rollup/plugin-babel v7+, the `transform` hook is the object form
-   * `{ filter, handler }` rather than a plain function. Normalize to the
-   * underlying handler so we can invoke it directly.
-   */
-  const originalTransform = (
-    typeof original.transform === "function" ? original.transform : original.transform?.handler
-  )!;
-
-  const babelMacros = new Set(babelRequiredImports);
-  if (env.mode === "development") {
-    babelMacros.delete("@ember/debug");
-  }
-
-  async function doTransform(this: any, code: string, id: string) {
-    counts.total++;
-
-    const ext = id.split(".").at(-1);
-    const lang = (ext === "gjs" ? "js" : ext === "gts" ? "ts" : ext) as
-      | "js"
-      | "ts"
-      | "jsx"
-      | "tsx"
-      | "dts"
-      | undefined;
-
-    let needsBabel = false;
-
-    const estree = await oxcParse(id, code, { lang });
-
-    walk(
-      estree.program as any,
-      /* state */ {},
-      {
-        Decorator(_node: any, { stop }: any) {
-          needsBabel = true;
-          counts.why.decorators++;
-          stop();
-        },
-        MemberExpression(node: any, { stop }: any) {
-          if (node.property?.name === "formatMessage" && node.object?.name === "intl") {
-            needsBabel = true;
-            counts.why.formatMessage++;
-            stop();
-          }
-        },
-        ImportDeclaration(node: any, { stop }: any) {
-          const value = node.source.value;
-          if (babelMacros.has(value)) {
-            needsBabel = true;
-
-            if (babelTemplateImports.has(value)) {
-              counts.why.imports.templates++;
-            } else if (babelMacroImports.has(value)) {
-              counts.why.imports.macros++;
-            } else {
-              counts.why.imports.other++;
-            }
-
-            stop();
-          }
-        },
-      },
-    );
-
-    if (!needsBabel && code.includes("initializeRuntimeMacrosConfig")) {
-      counts.why.initializeRuntimeMacrosConfig++;
-      needsBabel = true;
-    }
-
-    if (needsBabel) {
-      counts.babel++;
-
-      const result = await originalTransform.call(this, code, id);
-
-      return result;
-    }
-
-    if (ext === "json") {
-      return;
-    }
-
-    if (ext === "js" || ext === "gjs") {
-      // We don't need to process JS
-      return null;
-    }
-
-    const result = await transform(id, code, {
-      lang,
-      typescript: {
-        onlyRemoveTypeImports: true,
-        /**
-         * We should work towards disabling this.
-         */
-        allowNamespaces: true,
-        removeClassFieldsWithoutInitializer: false,
-        rewriteImportExtensions: false,
-      },
-    });
-
-    if (result.errors?.length) {
-      console.error(`Errors during oxc-transform of ${id}:`);
-      for (const err of result.errors) {
-        if (err.labels) {
-          console.error(err.labels);
-        }
-        console.error(err.codeframe || err.message);
-      }
-      throw result.errors;
-    }
-
-    return result;
-  }
-
-  return {
-    enforce: "pre",
-    buildEnd() {
-      if (process.env.INSPECT) {
-        console.debug(`Babel usage: ${counts.babel} / ${counts.total}`, counts.why);
-      }
-    },
-    ...original,
-    name: "nullvoxpopuli:babel",
-    transform: {
-      filter: {
-        id: {
-          include: [/\.js/, /\.gjs/, /\.ts/, /\.gts/],
-          exclude: [/\.json/],
-        },
-        // Enabling this opts us out of template compilation
-        // it's an AND instead of OR
-        // code: {
-        // 	include: [/initializeRuntimeMacrosConfig/, /precompileTemplate/],
-        // },
-      },
-      handler(this: any, code: string, id: string) {
-        try {
-          return doTransform.call(this, code, id);
-        } catch (e) {
-          // Use VSCode JavaScript Debug Terminal
-          // eslint-disable-next-line no-debugger
-          debugger;
-          throw e;
-        }
-      },
-    },
-  };
-}

package/src/layers/qunit/files/run-tests.mjs

@@ -1,30 +0,0 @@
-import { chromium } from "playwright";
-
-const browser = await chromium.launch();
-const page = await browser.newPage();
-
-page.on("console", (msg) => console.log(msg.text()));
-
-await page.goto("http://localhost:4173/tests");
-
-await page.waitForFunction(
-  () => {
-    const elem = document.getElementById("qunit-testresult");
-    return elem?.classList.contains("complete");
-  },
-  { timeout: 30000 },
-);
-
-const failed = await page.evaluate(() => {
-  const elem = document.getElementById("qunit-testresult");
-  return elem?.querySelector(".failed")?.textContent;
-});
-
-await browser.close();
-
-if (failed && parseInt(failed) > 0) {
-  console.error(`❌ ${failed} test(s) failed`);
-  process.exit(1);
-}
-
-console.log("✅ All tests passed!");

package/src/layers/vitest/files/tests/test-helper.ts

@@ -1,5 +0,0 @@
-import Application from "#app/app.ts";
-import config from "#app/config.ts";
-import { setApplication } from "@ember/test-helpers";
-
-setApplication(Application.create(config));