complete-cli 1.0.1-dev.0

package/src/commands/PublishCommand.ts

@@ -0,0 +1,242 @@
+import { Command, Option } from "clipanion";
+import { isSemanticVersion } from "complete-common";
+import type { PackageManager } from "complete-node";
+import {
+  $,
+  $s,
+  fatalError,
+  getPackageJSONField,
+  getPackageJSONVersion,
+  getPackageManagerInstallCommand,
+  getPackageManagerLockFileName,
+  getPackageManagersForProject,
+  isFile,
+  isGitRepository,
+  isGitRepositoryClean,
+  isLoggedInToNPM,
+  readFile,
+  updatePackageJSONDependencies,
+  writeFile,
+} from "complete-node";
+import path from "node:path";
+import { CWD, DEFAULT_PACKAGE_MANAGER } from "../constants.js";
+
+export class PublishCommand extends Command {
+  static override paths = [["publish"], ["p"]];
+
+  // The first positional argument.
+  versionBumpType = Option.String({
+    required: true,
+  });
+
+  dryRun = Option.Boolean("--dry-run", false, {
+    description: "Skip committing/uploading & perform a Git reset afterward.",
+  });
+
+  skipLint = Option.Boolean("--skip-lint", false, {
+    description: "Skip linting before publishing.",
+  });
+
+  skipUpdate = Option.Boolean("--skip-update", false, {
+    description: "Skip updating the npm dependencies.",
+  });
+
+  static override usage = Command.Usage({
+    description: "Bump the version & publish a new release.",
+  });
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async execute(): Promise<void> {
+    validate();
+    prePublish(
+      this.versionBumpType,
+      this.dryRun,
+      this.skipLint,
+      this.skipUpdate,
+    );
+    publish(this.dryRun);
+  }
+}
+
+function validate() {
+  if (!isGitRepository(CWD)) {
+    fatalError(
+      "Failed to publish since the current working directory is not inside of a git repository.",
+    );
+  }
+
+  if (!isGitRepositoryClean(CWD)) {
+    fatalError(
+      "Failed to publish since the Git repository was dirty. Before publishing, you must push any current changes to git. (Version commits should not contain any code changes.)",
+    );
+  }
+
+  if (!isFile("package.json")) {
+    fatalError(
+      'Failed to find the "package.json" file in the current working directory.',
+    );
+  }
+
+  if (!isLoggedInToNPM()) {
+    fatalError(
+      'Failed to publish since you are not logged in to npm. Try doing "npm login".',
+    );
+  }
+}
+
+/**
+ * Before uploading the project, we want to update dependencies, increment the version, and perform
+ * some other steps.
+ */
+function prePublish(
+  versionBumpType: string,
+  dryRun: boolean,
+  skipLint: boolean,
+  skipUpdate: boolean,
+) {
+  const packageManager = getPackageManagerUsedForExistingProject();
+
+  $s`git pull --rebase`;
+  $s`git push`;
+  updateDependencies(skipUpdate, dryRun, packageManager);
+  incrementVersion(versionBumpType);
+  unsetDevelopmentConstants();
+
+  tryRunNPMScript("build");
+  if (!skipLint) {
+    tryRunNPMScript("lint");
+  }
+}
+
+function getPackageManagerUsedForExistingProject(): PackageManager {
+  const packageManagers = getPackageManagersForProject(CWD);
+  if (packageManagers.length > 1) {
+    const packageManagerLockFileNames = packageManagers
+      .map((packageManager) => getPackageManagerLockFileName(packageManager))
+      .map((packageManagerLockFileName) => `"${packageManagerLockFileName}"`)
+      .join(" & ");
+    fatalError(
+      `Multiple different kinds of package manager lock files were found (${packageManagerLockFileNames}). You should delete the ones that you are not using so that this program can correctly detect your package manager.`,
+    );
+  }
+
+  const packageManager = packageManagers[0];
+  if (packageManager !== undefined) {
+    return packageManager;
+  }
+
+  return DEFAULT_PACKAGE_MANAGER;
+}
+
+function updateDependencies(
+  skipUpdate: boolean,
+  dryRun: boolean,
+  packageManager: PackageManager,
+) {
+  if (skipUpdate) {
+    return;
+  }
+
+  console.log('Updating dependencies in the "package.json" file...');
+  const hasNewDependencies = updatePackageJSONDependencies(undefined);
+  if (hasNewDependencies) {
+    const command = getPackageManagerInstallCommand(packageManager);
+    const commandParts = command.split(" ");
+    $s`${commandParts}`;
+    if (!dryRun) {
+      gitCommitAllAndPush("chore: update dependencies");
+    }
+  }
+}
+
+function gitCommitAllAndPush(message: string) {
+  $s`git add --all`;
+  $s`git commit --message ${message}`;
+  $s`git push`;
+  console.log(
+    `Committed and pushed to the git repository with a message of: ${message}`,
+  );
+}
+
+function incrementVersion(versionBumpType: string) {
+  if (versionBumpType === "none") {
+    return;
+  }
+
+  if (versionBumpType === "dev") {
+    throw new Error(
+      'The version bump type of "dev" is not currently supported.',
+    );
+  }
+
+  if (
+    versionBumpType !== "major" &&
+    versionBumpType !== "minor" &&
+    versionBumpType !== "patch" &&
+    versionBumpType !== "dev" &&
+    !isSemanticVersion(versionBumpType)
+  ) {
+    fatalError(
+      'The version must be one of "major", "minor", "patch", "dev", "none", or a specific semantic version like "1.2.3".',
+    );
+  }
+
+  // We always use `npm` here to avoid differences with the version command between package
+  // managers. The "--no-git-tag-version" flag will prevent npm from both making a commit and adding
+  // a tag.
+  $s`npm version ${versionBumpType} --no-git-tag-version`;
+}
+
+function unsetDevelopmentConstants() {
+  const constantsTSPath = path.join(CWD, "src", "constants.ts");
+  if (!isFile(constantsTSPath)) {
+    return;
+  }
+
+  const constantsTS = readFile(constantsTSPath);
+  const newConstantsTS = constantsTS
+    .replace("const IS_DEV = true", "const IS_DEV = false")
+    .replace("const DEBUG = true", "const DEBUG = false");
+  writeFile(constantsTSPath, newConstantsTS);
+}
+
+function tryRunNPMScript(scriptName: string) {
+  console.log(`Running: ${scriptName}`);
+
+  const $$ = $({
+    reject: false,
+  });
+  const { exitCode } = $$.sync`npm run ${scriptName}`;
+
+  if (exitCode !== 0) {
+    $s`git reset --hard`; // Revert the version changes.
+    fatalError(`Failed to run "${scriptName}".`);
+  }
+}
+
+function publish(dryRun: boolean) {
+  const projectName = getPackageJSONField(undefined, "name");
+  const version = getPackageJSONVersion(undefined);
+
+  if (dryRun) {
+    $s`git reset --hard`; // Revert the version changes.
+  } else {
+    const releaseGitCommitMessage = getReleaseGitCommitMessage(version);
+    gitCommitAllAndPush(releaseGitCommitMessage);
+
+    // - The "--access=public" flag is only technically needed for the first publish (unless the
+    //   package is a scoped package), but it is saved here for posterity.
+    // - The "--ignore-scripts" flag is needed since the "npm publish" command will run the
+    //   "publish" script in the "package.json" file, causing an infinite loop.
+    $s`npm publish --access=public --ignore-scripts`;
+  }
+
+  const dryRunSuffix = dryRun ? " (dry-run)" : "";
+  console.log(
+    `Published ${projectName} version ${version} successfully${dryRunSuffix}.`,
+  );
+}
+
+function getReleaseGitCommitMessage(version: string): string {
+  return `chore: release ${version}`;
+}

package/src/commands/UpdateCommand.ts

@@ -0,0 +1,20 @@
+import { Command } from "clipanion";
+import { updatePackageJSONDependencies } from "complete-node";
+
+export class UpdateCommand extends Command {
+  static override paths = [["update"], ["u"]];
+
+  static override usage = Command.Usage({
+    description:
+      'Invoke "npm-check-updates" to update the dependencies inside of the "package.json" file and then install them.',
+  });
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async execute(): Promise<void> {
+    const hasNewDependencies = updatePackageJSONDependencies();
+    const msg = hasNewDependencies
+      ? "Successfully installed new Node.js dependencies."
+      : "There were no new dependency updates from npm.";
+    console.log(msg);
+  }
+}

package/src/commands/check/check.test.ts

@@ -0,0 +1,123 @@
+import { strictEqual } from "node:assert";
+import test from "node:test";
+import { getTruncatedText } from "./getTruncatedText.js";
+
+test("no markers", () => {
+  const templateText = `
+line 1
+line 2
+line 3
+`.trim();
+
+  const { text } = getTruncatedText("test", templateText, new Set(), new Set());
+  strictEqual(text, templateText);
+});
+
+test("customization marker", () => {
+  const templateText = `
+line 1
+@template-customization-start
+line 2
+@template-customization-end
+line 3
+  `.trim();
+
+  const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+
+  const { text } = getTruncatedText("test", templateText, new Set(), new Set());
+  strictEqual(text, expectedTemplateText);
+});
+
+test("ignore block marker part 1", () => {
+  const templateText = `
+line 1
+@template-ignore-block-start
+// line 2
+@template-ignore-block-end
+line 3
+  `.trim();
+
+  const parsedTemplateText = `
+line 1
+line 3
+  `.trim();
+
+  const { text, ignoreLines } = getTruncatedText(
+    "test",
+    templateText,
+    new Set(),
+    new Set(),
+  );
+  strictEqual(text, parsedTemplateText);
+  strictEqual(ignoreLines.size, 1);
+  strictEqual([...ignoreLines][0], "line 2");
+});
+
+test("ignore block marker part 2", () => {
+  const templateText = `
+line 1
+line 2
+line 3
+  `.trim();
+
+  const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+
+  const { text } = getTruncatedText(
+    "test",
+    templateText,
+    new Set(["line 2"]),
+    new Set(),
+  );
+  strictEqual(text, expectedTemplateText);
+});
+
+test("ignore next line part 1", () => {
+  const templateText = `
+line 1
+@template-ignore-next-line
+line 2
+line 3
+  `.trim();
+
+  const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+
+  const { text, linesBeforeIgnore } = getTruncatedText(
+    "test",
+    templateText,
+    new Set(),
+    new Set(),
+  );
+  strictEqual(linesBeforeIgnore.size, 1);
+  strictEqual([...linesBeforeIgnore][0], "line 1");
+  strictEqual(text, expectedTemplateText);
+});
+
+test("ignore next line part 2", () => {
+  const templateText = `
+line 1
+line 2
+line 3
+  `.trim();
+
+  const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+
+  const { text } = getTruncatedText(
+    "test",
+    templateText,
+    new Set(),
+    new Set(["line 1"]),
+  );
+  strictEqual(text, expectedTemplateText);
+});

package/src/commands/check/getTruncatedText.ts

@@ -0,0 +1,187 @@
+import { getEnumValues, trimPrefix } from "complete-common";
+import {
+  fatalError,
+  getPackageManagerLockFileNames,
+  PackageManager,
+} from "complete-node";
+
+const MARKER_CUSTOMIZATION_START = "@template-customization-start";
+const MARKER_CUSTOMIZATION_END = "@template-customization-end";
+const MARKER_IGNORE_BLOCK_START = "@template-ignore-block-start";
+const MARKER_IGNORE_BLOCK_END = "@template-ignore-block-end";
+const MARKER_IGNORE_NEXT_LINE = "@template-ignore-next-line";
+
+const PACKAGE_MANAGER_STRINGS = [
+  "PACKAGE_MANAGER_NAME",
+  "PACKAGE_MANAGER_INSTALL_COMMAND",
+  "PACKAGE_MANAGER_LOCK_FILE_NAME",
+  ...getEnumValues(PackageManager),
+  ...getPackageManagerLockFileNames(),
+] as const;
+
+/**
+ * @param fileName Used to perform some specific rules based on the template file name.
+ * @param text The text to parse.
+ * @param ignoreLines A set of lines to remove from the text.
+ * @param linesBeforeIgnore A set of lines that will trigger the subsequent line to be ignored.
+ * @returns The text of the file with all text removed between any flagged markers (and other
+ *          specific hard-coded exclusions), as well as an array of lines that had a
+ *          "ignore-next-line" marker below them.
+ */
+export function getTruncatedText(
+  fileName: string,
+  text: string,
+  ignoreLines: ReadonlySet<string>,
+  linesBeforeIgnore: ReadonlySet<string>,
+): {
+  text: string;
+  ignoreLines: ReadonlySet<string>;
+  linesBeforeIgnore: ReadonlySet<string>;
+} {
+  const lines = text.split("\n");
+
+  const newLines: string[] = [];
+  const newIgnoreLines = new Set<string>();
+  const newLinesBeforeIgnore = new Set<string>();
+
+  let isSkipping = false;
+  let isIgnoring = false;
+  let shouldIgnoreNextLine = false;
+  let previousLine = "";
+
+  for (const line of lines) {
+    if (line.trim() === "") {
+      continue;
+    }
+
+    if (ignoreLines.has(line.trim())) {
+      continue;
+    }
+
+    if (shouldIgnoreNextLine) {
+      shouldIgnoreNextLine = false;
+      continue;
+    }
+
+    if (linesBeforeIgnore.has(line)) {
+      shouldIgnoreNextLine = true;
+    }
+
+    // -------------
+    // Marker checks
+    // -------------
+
+    if (line.includes(MARKER_CUSTOMIZATION_START)) {
+      isSkipping = true;
+      continue;
+    }
+
+    if (line.includes(MARKER_CUSTOMIZATION_END)) {
+      isSkipping = false;
+      continue;
+    }
+
+    if (line.includes(MARKER_IGNORE_BLOCK_START)) {
+      isIgnoring = true;
+      continue;
+    }
+
+    if (line.includes(MARKER_IGNORE_BLOCK_END)) {
+      isIgnoring = false;
+      continue;
+    }
+
+    if (line.includes(MARKER_IGNORE_NEXT_LINE)) {
+      shouldIgnoreNextLine = true;
+
+      // We mark the previous line so that we know the next line to skip in the template.
+      if (previousLine.trim() === "") {
+        fatalError(
+          `You cannot have a "${MARKER_IGNORE_NEXT_LINE}" marker before a blank line in the "${fileName}" file.`,
+        );
+      }
+      newLinesBeforeIgnore.add(previousLine);
+
+      continue;
+    }
+
+    if (isIgnoring) {
+      const baseLine = trimPrefix(line.trim(), "// ");
+      newIgnoreLines.add(baseLine);
+      continue;
+    }
+
+    // --------------------
+    // Specific file checks
+    // --------------------
+
+    // We should ignore imports in JavaScript or TypeScript files.
+    if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+      if (line === "import {") {
+        isSkipping = true;
+        continue;
+      }
+
+      if (line.startsWith("} from ")) {
+        isSkipping = false;
+        continue;
+      }
+
+      if (line.startsWith("import ")) {
+        continue;
+      }
+    }
+
+    // End-users can have different ignored words.
+    if (
+      fileName === "cspell.config.jsonc" ||
+      fileName === "_cspell.config.jsonc"
+    ) {
+      if (line.match(/"words": \[.*]/) !== null) {
+        continue;
+      }
+
+      if (line.includes('"words": [')) {
+        isSkipping = true;
+        continue;
+      }
+
+      if ((line.endsWith("]") || line.endsWith("],")) && isSkipping) {
+        isSkipping = false;
+        continue;
+      }
+    }
+
+    if (fileName === "ci.yml" || fileName === "action.yml") {
+      // End-users can have different package managers.
+      if (hasPackageManagerString(line)) {
+        continue;
+      }
+
+      // Ignore comments, since end-users are expected to delete the explanations.
+      if (line.match(/^\s*#/) !== null) {
+        continue;
+      }
+    }
+
+    // ------------
+    // Final checks
+    // ------------
+
+    if (!isSkipping) {
+      newLines.push(line);
+      previousLine = line;
+    }
+  }
+
+  const newText = newLines.join("\n");
+  return {
+    text: newText,
+    ignoreLines: newIgnoreLines,
+    linesBeforeIgnore: newLinesBeforeIgnore,
+  };
+}
+
+function hasPackageManagerString(line: string) {
+  return PACKAGE_MANAGER_STRINGS.some((string) => line.includes(string));
+}

package/src/commands/init/checkIfProjectPathExists.ts

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import {
+  deleteFileOrDirectory,
+  fileOrDirectoryExists,
+  isDirectory,
+} from "complete-node";
+import { CWD } from "../../constants.js";
+import { getInputYesNo, promptEnd, promptLog } from "../../prompt.js";
+
+export async function checkIfProjectPathExists(
+  projectPath: string,
+  yes: boolean,
+): Promise<void> {
+  if (projectPath === CWD || !fileOrDirectoryExists(projectPath)) {
+    return;
+  }
+
+  const fileType = isDirectory(projectPath) ? "directory" : "file";
+
+  if (yes) {
+    deleteFileOrDirectory(projectPath);
+    promptLog(`Deleted ${fileType}: ${chalk.green(projectPath)}`);
+    return;
+  }
+
+  promptLog(
+    `A ${fileType} already exists with a name of: ${chalk.green(projectPath)}`,
+  );
+  const shouldDelete = await getInputYesNo("Do you want me to delete it?");
+
+  if (!shouldDelete) {
+    promptEnd("Ok then. Goodbye.");
+  }
+
+  deleteFileOrDirectory(projectPath);
+}