ember.nvp 0.1.0 → 0.2.0

package/src/utils/project.js

@@ -0,0 +1,249 @@
+import { $ } from "execa";
+import { existsSync } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { hasGit } from "#utils/git.js";
+import { assert } from "node:console";
+import { layers, layerNames } from "#layers";
+
+/**
+ * State container for the project.
+ *
+ * May eventually include information for discovering existing state
+ * about a project.
+ */
+export class Project {
+  #directory;
+  #desires;
+
+  /**
+   *
+   * @param {string} atDirectory
+   * @param {import('./types.ts').Answers} desires
+   */
+  constructor(atDirectory, desires) {
+    this.#directory = atDirectory;
+    this.#desires = desires;
+  }
+
+  /**
+   * @type {string}
+   */
+  get name() {
+    return this.desires.name;
+  }
+
+  /**
+   * @type {import('#types').ProjectType}
+   */
+  get type() {
+    return this.desires.type;
+  }
+
+  /**
+   * @type {import('#types').PackageManager}
+   */
+  get packageManager() {
+    return this.desires.packageManager;
+  }
+
+  /**
+   * @type {string}
+   */
+  get directory() {
+    return this.#directory;
+  }
+
+  /**
+   * @type {import('./types.ts').Answers}
+   */
+  get desires() {
+    return this.#desires;
+  }
+
+  /**
+   * @param {string} name
+   * @returns {Promise<boolean>}
+   */
+  async #hasLayer(name) {
+    let layer = layers.find((layer) => layer.name === name);
+
+    if (!layer) return false;
+
+    return layer.isSetup(this);
+  }
+
+  /**
+   * @param {string} name
+   * @returns {Promise<boolean>}
+   */
+  async hasLayer(name) {
+    switch (name) {
+      case "eslint": {
+        let eslints = layerNames.filter((name) => name.startsWith("eslint"));
+        let results = await Promise.all(eslints.map((name) => this.#hasLayer(name)));
+
+        return results.some(Boolean);
+      }
+      case "testing": {
+        let results = await Promise.all([this.#hasLayer("qunit"), this.#hasLayer("vitest")]);
+
+        return results.some(Boolean);
+      }
+      default: {
+        return this.#hasLayer(name);
+      }
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
+  wantsLayer(name) {
+    switch (name) {
+      case "eslint": {
+        return this.desires.layers.some((layer) => layer.name.startsWith("eslint"));
+      }
+      case "testing": {
+        return this.desires.layers.some(
+          (layer) => layer.name === "qunit" || layer.name === "vitest",
+        );
+      }
+      default: {
+        return this.desires.layers.some((layer) => layer.name === name);
+      }
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @returns {Promise<boolean>}
+   */
+  async hasOrWantsLayer(name) {
+    return this.wantsLayer(name) || this.hasLayer(name);
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  get wantsTypeScript() {
+    return this.wantsLayer("typescript");
+  }
+
+  /**
+   *
+   * @param {string} relativePath
+   * @returns {string}
+   */
+  path(relativePath) {
+    assert(typeof relativePath === "string");
+    assert(!relativePath.startsWith("/"), "relativePath must be relative");
+    assert(!relativePath.includes(".."), "relativePath must not traverse directories");
+
+    return join(this.directory, relativePath);
+  }
+
+  /**
+   *
+   * @param {string} relativePath
+   * @returns {boolean}
+   */
+  hasFile(relativePath) {
+    let path = this.path(relativePath);
+
+    return existsSync(path);
+  }
+
+  /**
+   *
+   * @param {string} relativePath
+   * @returns {Promise<string|undefined>}
+   */
+  async read(relativePath) {
+    let path = this.path(relativePath);
+
+    if (existsSync(path)) {
+      return await readFile(path, "utf-8");
+    }
+
+    return;
+  }
+
+  /**
+   *
+   * @param {string} relativePath
+   */
+  async removeFile(relativePath) {
+    let path = this.path(relativePath);
+
+    if (existsSync(path)) {
+      await rm(path);
+    }
+  }
+
+  /**
+   * @param {string} command
+   * @returns {import('execa').ResultPromise}
+   */
+  run(command) {
+    return $(command, { cwd: this.directory, shell: true });
+  }
+
+  /**
+   * @returns {import('execa').ResultPromise}
+   */
+  install() {
+    return this.run(`${this.desires.packageManager} install`);
+  }
+
+  /**
+   * @param {string} [files='.'] files to add to git, defaults to all files
+   * @returns {import('execa').ResultPromise | undefined}
+   */
+  gitAdd(files = ".") {
+    if (!hasGit(this.directory)) return;
+
+    return this.run(`git add ${files}`);
+  }
+
+  /**
+   * @param {string} message commit message
+   * @returns {import('execa').ResultPromise | undefined}
+   */
+  gitCommit(message) {
+    if (!hasGit(this.directory)) return;
+
+    return this.run(`git commit -m ${JSON.stringify(message)}`);
+  }
+
+  /**
+   * @returns {Promise<string | undefined>}
+   */
+  async gitLastCommitMessage() {
+    if (!hasGit(this.directory)) return;
+
+    try {
+      const result = await this.run("git log -1 --pretty=%B");
+      const stdout = result.stdout;
+      return typeof stdout === "string" ? stdout.trim() : undefined;
+    } catch {
+      return;
+    }
+  }
+
+  /**
+   * @returns {Promise<boolean>}
+   */
+  async gitHasDiff() {
+    if (!hasGit(this.directory)) return false;
+
+    try {
+      await this.run("git diff --exit-code");
+      await this.run("git diff --staged --exit-code");
+      return false; // exit code 0 means no diff
+    } catch {
+      return true; // exit code 1 means there is a diff
+    }
+  }
+}

package/src/utils/remove-types.js

@@ -0,0 +1,90 @@
+import { Preprocessor } from "content-tag";
+import { removeTypes as babelRemoveTypes } from "babel-remove-types";
+import { substringBytes } from "./buffer.js";
+
+/**
+ * Inspired by https://github.com/ember-cli/ember-cli/blob/8ea5b2e22d37805f5749a4917e0ef25fac3c9cda/lib/models/blueprint.js#L537
+ * @param {*} extension
+ * @param {*} code
+ * @returns
+ */
+export async function removeTypes(extension, code) {
+  if (extension === ".gts") {
+    return await wrappedRemoveTypes(code, babelRemoveTypes);
+  }
+
+  if (extension === ".ts") {
+    return await babelRemoveTypes(code);
+  }
+
+  return code;
+}
+
+/**
+ *
+ * Support for removeTypes
+ *
+ */
+
+const preprocessor = new Preprocessor();
+/**
+ * Builds a class field placeholder for a template block.
+ * @param {number} i index of the template occurrence
+ */
+function replacementClassMember(i = 0) {
+  return `template = __TEMPLATE_TAG_${i}__;`;
+}
+
+/**
+ * Builds an expression placeholder for a template block.
+ * @param {number} i index of the template occurrence
+ */
+function replacementExpression(i = 0) {
+  return `__TEMPLATE_TAG_${i}__`;
+}
+
+async function wrappedRemoveTypes(code = "", callback = babelRemoveTypes) {
+  // Strip template tags
+  const templateTagMatches = preprocessor.parse(code);
+  let strippedCode = code;
+
+  for (const [i, match] of templateTagMatches.entries()) {
+    const templateTag = substringBytes(code, match.range.startByte, match.range.endByte);
+
+    if (match.type === "class-member") {
+      strippedCode = strippedCode.replace(templateTag, replacementClassMember(i));
+    } else {
+      strippedCode = strippedCode.replace(templateTag, replacementExpression(i));
+    }
+  }
+
+  // Remove types
+  const transformed = await callback(strippedCode);
+
+  // Readd stripped template tags
+  let transformedWithTemplateTag = transformed;
+
+  for (const [i, match] of templateTagMatches.entries()) {
+    const templateTag = substringBytes(code, match.range.startByte, match.range.endByte);
+
+    if (match.type === "class-member") {
+      transformedWithTemplateTag = transformedWithTemplateTag.replace(
+        replacementClassMember(i),
+        templateTag,
+      );
+    } else {
+      // babel-remove-types uses prettier under the hood, and adds trailing `;` where allowed,
+      // so we need to take that into account when restoring the template tags:
+      transformedWithTemplateTag = transformedWithTemplateTag.replace(
+        `${replacementExpression(i)};`,
+        templateTag,
+      );
+      transformedWithTemplateTag = transformedWithTemplateTag.replace(
+        replacementExpression(i),
+        templateTag,
+      );
+    }
+  }
+
+  return transformedWithTemplateTag;
+}

package/src/utils/types.ts

@@ -0,0 +1,48 @@
+import { Project } from "./project.js";
+export type PackageManager = "pnpm" | "npm";
+export type ProjectType = "app" | "library";
+
+export interface Layer {
+  /**
+   * The text to show during selection
+   */
+  label: string;
+  hint?: string;
+  defaultValue?: () => unknown;
+  /**
+   * The function that applies the codemod
+   *
+   * run _may_ be invoked multiple times,
+   * so it's important to not require interaction here
+   */
+  run: (project: Project) => Promise<void>;
+  isSetup: <Explain extends boolean = false>(
+    project: Project,
+    explain?: Explain,
+  ) => Promise<
+    Explain extends true
+      ? {
+          isSetup: boolean;
+          reasons: string[];
+        }
+      : boolean
+  >;
+}
+
+export interface DiscoveredLayer extends Layer {
+  /**
+   * The unique name of the layer
+   * (exact match of the folder name
+   *   not provided by the layer
+   * )
+   */
+  name: string;
+}
+
+export interface Answers {
+  type: ProjectType;
+  path: string;
+  name: string;
+  layers: DiscoveredLayer[];
+  packageManager: PackageManager;
+}

package/test/ember.nvp/cli.test.ts

@@ -0,0 +1,12 @@
+import { test, expect as hardExpect } from "vitest";
+import { cli } from "#test-helpers";
+
+const expect = hardExpect.soft;
+
+test.skip("cli works", async () => {
+  let { execaPromise, output, input } = cli();
+
+  await execaPromise;
+
+  expect(execaPromise.exitCode).toBe(0);
+});

package/test/ember.nvp/layers.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { discoverLayers } from "#layers";
+
+const layers = await discoverLayers();
+
+describe("discoverLayers", () => {
+  it("includes expected layer names", async () => {
+    const layers = await discoverLayers();
+    const layerNames = layers.map((layer) => layer.name);
+
+    expect(layerNames).toMatchInlineSnapshot(`
+      [
+        "eslint-bundled-ember",
+        "eslint-bundled-nvp",
+        "git",
+        "github-actions",
+        "prettier",
+        "qunit",
+        "renovate",
+        "typescript",
+      ]
+    `);
+  });
+
+  describe("each layer has minimum API", () => {
+    for (let layer of layers) {
+      it(layer.name, () => {
+        const keys = Object.keys(layer);
+        expect(keys).toContain("name");
+        expect(keys).toContain("label");
+        expect(keys).toContain("run");
+      });
+    }
+  });
+});

package/test/ember.nvp/permutations.test.ts

@@ -0,0 +1,200 @@
+import { beforeAll, describe, it, expect, afterAll } from "vitest";
+import { generate, permutate, bases, layers, reapply } from "#test-helpers";
+import { TODO } from "#layers";
+
+import type { Project } from "ember.nvp";
+import { rimraf } from "rimraf";
+
+let permutations = permutate(layers.map((layer) => layer.name));
+
+const baseline = "<baseline>";
+permutations.push([baseline]);
+
+const RE_APPLY_ONLY = new Set<string>([
+  // "typescript"
+  // "renovate",
+  // "github-actions",
+]);
+const INITIAL_ONLY = new Set<string>([
+  // baseline,
+  // "eslint-bundled-nvp",
+  // "typescript"
+]);
+
+const eachBase = bases
+  .map((base) => ({ name: base }))
+  .filter(({ name }) => {
+    if (name === "minimal-library") {
+      /** TODO **/
+      return false;
+    }
+
+    return true;
+  });
+const eachPermutation = permutations
+  .filter((permutation) => {
+    if (INITIAL_ONLY.size > 0 && !permutation.some((x) => INITIAL_ONLY.has(x))) {
+      return;
+    }
+
+    // Not implemented yet
+    if (permutation.some((x) => TODO.has(x))) {
+      return;
+    }
+
+    return true;
+  })
+  .map((permutation) => ({ permutation, name: permutation.join(", ") }));
+
+describe.each(eachBase)("$name", ({ name: base }) => {
+  describe.each(eachPermutation)("layers: $name", ({ permutation }) => {
+    let project: Project;
+    let layerNames = permutation.filter((x) => x !== baseline);
+    let startingLayers = layers.filter((layer) => layerNames.includes(layer.name));
+
+    beforeAll(async () => {
+      project = await generate({
+        type: base === "minimal-app" ? "app" : "library",
+        layers: layerNames,
+      });
+    });
+
+    afterAll(async () => {
+      if (process.env.CI) {
+        return;
+      }
+
+      if (project?.directory) {
+        await rimraf(project.directory, { maxRetries: 3, retryDelay: 100 });
+      }
+    });
+
+    it("successfully setup the layers", async () => {
+      if (startingLayers.length === 0) {
+        // TODO: test baseline stuff more?
+        expect(true, "No layers to verify").toBe(true);
+      }
+
+      for (let layer of startingLayers) {
+        expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+        let result = await layer.isSetup(project);
+
+        expect(result, `${layer.name} is setup`).toBe(true);
+      }
+    });
+
+    /**
+     * Are these valuable? no one would invoke the layers like this
+     */
+    // describe.skip("(re)applying", () => {
+    //   for (let layer of layers) {
+    //     if (RE_APPLY_ONLY.size > 0 && !RE_APPLY_ONLY.has(layer.name)) {
+    //       continue;
+    //     }
+
+    //     if (TODO.has(layer.name)) {
+    //       continue;
+    //     }
+
+    //     describe(layer.name, () => {
+    //       let expected = startingLayers.find((l) => l.name === layer.name);
+
+    //       beforeAll(async () => {
+    //         await layer.run(project);
+    //       });
+
+    //       if (expected) {
+    //         it("is applied", async () => {
+    //           expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+    //           let result = await layer.isSetup(project, true);
+
+    //           if (typeof result === "object") {
+    //             expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+    //             expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+    //             return;
+    //           }
+
+    //           expect(result, `${layer.name} is setup`).toBe(true);
+
+    //           return;
+    //         });
+    //       } else {
+    //         it("is not applied", async () => {
+    //           expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+    //           let result = await layer.isSetup(project, true);
+
+    //           if (typeof result === "object") {
+    //             expect(result.isSetup, `${layer.name} is not setup`).toBe(false);
+    //             hardExpect(result.reasons.length, `${layer.name} is not setup`).toBeGreaterThan(0);
+    //             return;
+    //           }
+
+    //           expect(result, `${layer.name} is not setup`).toBe(false);
+    //         });
+    //       }
+    //     });
+    //   }
+    // });
+
+    /**
+     * Simulates running the CLI again with different options selected
+     * on the same project
+     */
+    describe("apply anew", () => {
+      let newLayers = layers
+        .filter((layer) => {
+          if (RE_APPLY_ONLY.size > 0 && !RE_APPLY_ONLY.has(layer.name)) {
+            return false;
+          }
+
+          if (TODO.has(layer.name)) {
+            return false;
+          }
+
+          return true;
+        })
+        .map((layer) => ({ name: layer.name, layer }));
+
+      describe.each(newLayers)("$name", ({ layer }) => {
+        beforeAll(async () => {
+          // Simulate running the CLI again, adding one more option while
+          // keeping the previously-selected layers.
+          await reapply(project, [...new Set([...layerNames, layer.name])]);
+        });
+
+        it.for(startingLayers)("starting layers still present: $name", async (layer) => {
+          expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+          let result = await layer.isSetup(project, true);
+
+          if (typeof result === "object") {
+            expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+            expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+            return;
+          }
+
+          expect(result, `${layer.name} is setup`).toBe(true);
+        });
+
+        it("is applied", async () => {
+          expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+          let result = await layer.isSetup(project, true);
+
+          if (typeof result === "object") {
+            expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+            expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+            return;
+          }
+
+          expect(result, `${layer.name} is setup`).toBe(true);
+
+          return;
+        });
+      });
+    });
+  });
+});

package/test/manual.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+root=$(git rev-parse --show-toplevel)
+bin_path="$root/src/cli/index.js"
+
+tmp_dir=$(mktemp -d)
+
+cd $tmp_dir
+
+
+node $bin_path