isaacscript 1.2.26 → 1.2.29

package/src/commands/init/createMod.ts

@@ -1,7 +1,5 @@
 import chalk from "chalk";
-import commandExists from "command-exists";
 import path from "path";
-import yaml from "yaml";
 import * as configFile from "../../configFile";
 import {
   GITIGNORE,
@@ -14,29 +12,24 @@ import {
   METADATA_XML_TEMPLATE_PATH,
   PACKAGE_JSON,
   PACKAGE_JSON_TEMPLATE_PATH,
-  PROJECT_NAME,
   README_MD,
   README_MD_TEMPLATES_PATH,
   TEMPLATES_STATIC_DIR,
 } from "../../constants";
 import { execShell } from "../../exec";
 import * as file from "../../file";
-import { getInputString, getInputYesNo } from "../../prompt";
-import { GitHubCLIHostsYAML } from "../../types/GitHubCLIHostsYAML";
-import { error, parseSemVer } from "../../utils";
+import { initGitRepository } from "./git";
 
-const REQUIRED_GIT_MAJOR_VERSION = 2;
-const REQUIRED_GIT_MINOR_VERSION = 30;
-
-export async function createMod(
+export function createMod(
   projectName: string,
   projectPath: string,
   createNewDir: boolean,
   modsDirectory: string,
   saveSlot: number,
+  gitRemoteURL: string | undefined,
   skipNPMInstall: boolean,
   verbose: boolean,
-): Promise<void> {
+): void {
   if (createNewDir) {
     file.makeDir(projectPath, verbose);
   }
@@ -45,54 +38,17 @@ export async function createMod(
   configFile.createFile(projectPath, config, verbose);
   const targetModDirectory = path.join(config.modsDirectory, projectName);
 
-  await initGitRepository(projectPath, projectName, verbose);
   makeSubdirectories(projectPath, verbose);
   copyStaticFiles(projectPath, verbose);
   copyDynamicFiles(projectName, projectPath, targetModDirectory, verbose);
   updateNodeModules(projectPath, verbose);
   installNodeModules(projectPath, skipNPMInstall, verbose);
+  formatFiles(projectPath, verbose);
 
-  console.log(`Successfully created mod: ${chalk.green(projectName)}`);
-}
-
-async function initGitRepository(
-  projectPath: string,
-  projectName: string,
-  verbose: boolean,
-) {
-  if (!commandExists.sync("git")) {
-    console.log(
-      'Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.',
-    );
-    return;
-  }
-
-  checkOldGitVersion(verbose);
-
-  const remoteURL = await getGitRemoteURL(projectName);
-  if (remoteURL === "") {
-    return;
-  }
+  // Only make the initial commit once all of the files have been copied and formatted
+  initGitRepository(projectPath, gitRemoteURL, verbose);
 
-  execShell("git", ["init"], verbose, false, projectPath);
-  execShell("git", ["branch", "-M", "main"], verbose, false, projectPath);
-  execShell(
-    "git",
-    ["remote", "add", "origin", remoteURL],
-    verbose,
-    false,
-    projectPath,
-  );
-  if (isGitNameAndEmailConfigured(verbose)) {
-    execShell("git", ["add", "--all"], verbose, false, projectPath);
-    execShell(
-      "git",
-      ["commit", "--message", `${PROJECT_NAME} template`],
-      verbose,
-      false,
-      projectPath,
-    );
-  }
+  console.log(`Successfully created mod: ${chalk.green(projectName)}`);
 }
 
 function makeSubdirectories(projectPath: string, verbose: boolean) {
@@ -103,7 +59,7 @@ function makeSubdirectories(projectPath: string, verbose: boolean) {
   }
 }
 
-// Copy static files, like ".eslintrc.js", "tsconfig.json", etc.
+/** Copy static files, like ".eslintrc.js", "tsconfig.json", etc. */
 function copyStaticFiles(projectPath: string, verbose: boolean) {
   const staticFileList = file.getDirList(TEMPLATES_STATIC_DIR);
   staticFileList.forEach((fileName: string) => {
@@ -115,7 +71,7 @@ function copyStaticFiles(projectPath: string, verbose: boolean) {
   });
 }
 
-// Copy files that need to have text replaced inside of them
+/** Copy files that need to have text replaced inside of them. */
 function copyDynamicFiles(
   projectName: string,
   projectPath: string,
@@ -198,6 +154,7 @@ function copyDynamicFiles(
   }
 }
 
+/** The "package.json" file has to be copied first before this step. */
 function updateNodeModules(projectPath: string, verbose: boolean) {
   console.log("Finding out the latest versions of the NPM packages...");
   execShell(
@@ -209,122 +166,6 @@ function updateNodeModules(projectPath: string, verbose: boolean) {
   );
 }
 
-async function getGitRemoteURL(projectName: string) {
-  const guessedRemoteURL = guessRemoteURL(projectName);
-  if (guessedRemoteURL !== undefined) {
-    const shouldUseGuessedURL = await getInputYesNo(
-      `Do you want to use a Git remote URL of: ${chalk.green(
-        guessedRemoteURL,
-      )}`,
-    );
-    if (shouldUseGuessedURL) {
-      return guessedRemoteURL;
-    }
-  }
-
-  return getInputString(`Paste in the remote Git URL for your project.
-For example, if you have an SSH key, it would be something like:
-${chalk.green("git@github.com:Alice/green-candle.git")}
-If you don't have an SSH key, it would be something like:
-${chalk.green("https://github.com/Alice/green-candle.git")}
-If you don't want to initialize a Git repository for this project, press enter to skip.
-`);
-}
-
-function checkOldGitVersion(verbose: boolean) {
-  const [, stdout] = execShell("git", ["--version"], verbose);
-
-  const outputPrefix = "git version ";
-  if (!stdout.startsWith(outputPrefix)) {
-    error(
-      `Failed to parse the output from the "git --version" command: ${stdout}`,
-    );
-  }
-
-  const gitVersionString = stdout.slice(outputPrefix.length);
-  const [majorVersion, minorVersion] = parseSemVer(gitVersionString);
-
-  if (
-    majorVersion >= REQUIRED_GIT_MAJOR_VERSION &&
-    minorVersion >= REQUIRED_GIT_MINOR_VERSION
-  ) {
-    return;
-  }
-
-  console.error(`Your Git version is: ${chalk.red(gitVersionString)}`);
-  console.error(
-    `${PROJECT_NAME} requires a Git version of ${chalk.red(
-      `${REQUIRED_GIT_MAJOR_VERSION}.${REQUIRED_GIT_MINOR_VERSION}.0`,
-    )} or greater.`,
-  );
-  console.error(
-    `Please upgrade your version of Git before using ${PROJECT_NAME}.`,
-  );
-  process.exit(1);
-}
-
-function guessRemoteURL(projectName: string) {
-  const gitHubUsername = getGitHubUsername();
-  if (gitHubUsername === undefined) {
-    return undefined;
-  }
-
-  return `git@github.com:${gitHubUsername}/${projectName}.git`;
-}
-
-function getGitHubUsername() {
-  // If the GitHub CLI is installed, we can derive the user's GitHub username
-  if (
-    !commandExists.sync("gh") ||
-    process.env.APPDATA === undefined ||
-    process.env.APPDATA === ""
-  ) {
-    return undefined;
-  }
-
-  const githubCLIHostsPath = path.join(
-    process.env.APPDATA,
-    "GitHub CLI",
-    "hosts.yml",
-  );
-  if (!file.exists(githubCLIHostsPath)) {
-    return undefined;
-  }
-
-  const configYAMLRaw = file.read(githubCLIHostsPath);
-  const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
-
-  const githubCom = configYAML["github.com"];
-  if (githubCom === undefined) {
-    return undefined;
-  }
-
-  const { user } = githubCom;
-  if (user === "") {
-    return undefined;
-  }
-
-  return user;
-}
-
-function isGitNameAndEmailConfigured(verbose: boolean) {
-  const [nameExitStatus] = execShell(
-    "git",
-    ["config", "--global", "user.name"],
-    verbose,
-    true,
-  );
-
-  const [emailExitStatus] = execShell(
-    "git",
-    ["config", "--global", "user.email"],
-    verbose,
-    true,
-  );
-
-  return nameExitStatus === 0 && emailExitStatus === 0;
-}
-
 function installNodeModules(
   projectPath: string,
   skipNPMInstall: boolean,
@@ -337,3 +178,13 @@ function installNodeModules(
   console.log("Installing node modules... (This can take a long time.)");
   execShell("npm", ["install"], verbose, false, projectPath);
 }
+
+function formatFiles(projectPath: string, verbose: boolean) {
+  execShell(
+    "npx",
+    ["prettier", "--write", projectPath],
+    verbose,
+    false,
+    projectPath,
+  );
+}

package/src/commands/init/getProjectPath.ts

@@ -19,20 +19,28 @@ const ILLEGAL_CHARACTERS_FOR_WINDOWS_FILENAMES = [
 
 export async function getProjectPath(
   argv: Record<string, unknown>,
+  useCurrentDir: boolean,
+  yes: boolean,
 ): Promise<[string, boolean]> {
   let projectName = getProjectNameFromCommandLineArgument(argv);
   let projectPath: string;
   let createNewDir: boolean;
-  if (argv.useCurrentDir !== undefined) {
+  if (useCurrentDir) {
     // The "--use-current-dir" command-line flag was specified,
     // so there is no need to prompt the user
     projectName = CURRENT_DIRECTORY_NAME;
     projectPath = CWD;
     createNewDir = false;
-  } else if (projectName !== null) {
+  } else if (projectName !== undefined) {
     // The project name was specified on the command-line
     projectPath = path.join(CWD, projectName);
     createNewDir = true;
+  } else if (yes) {
+    // The "--yes" command-line flag was specified and the project name was not specified on the
+    // command-line, so default to using the current directory
+    projectName = CURRENT_DIRECTORY_NAME;
+    projectPath = CWD;
+    createNewDir = false;
   } else {
     // The project name was not specified on the command-line, so prompt the user for it
     [projectName, projectPath, createNewDir] = await getNewProjectName();
@@ -48,8 +56,10 @@ export async function getProjectPath(
 
 function getProjectNameFromCommandLineArgument(
   argv: Record<string, unknown>,
-): string | null {
-  return typeof argv.name === "string" && argv.name !== "" ? argv.name : null;
+): string | undefined {
+  return typeof argv.name === "string" && argv.name !== ""
+    ? argv.name
+    : undefined;
 }
 
 async function getNewProjectName(): Promise<[string, string, boolean]> {

package/src/commands/init/git.ts

@@ -0,0 +1,248 @@
+import chalk from "chalk";
+import commandExists from "command-exists";
+import path from "path";
+import yaml from "yaml";
+import { PROJECT_NAME } from "../../constants";
+import { execShell } from "../../exec";
+import * as file from "../../file";
+import { getInputString, getInputYesNo } from "../../prompt";
+import { GitHubCLIHostsYAML } from "../../types/GitHubCLIHostsYAML";
+import { error, parseSemVer } from "../../utils";
+
+const REQUIRED_GIT_MAJOR_VERSION = 2;
+const REQUIRED_GIT_MINOR_VERSION = 30;
+
+export async function promptGitHubRepoOrGitRemoteURL(
+  projectName: string,
+  yes: boolean,
+  verbose: boolean,
+): Promise<string | undefined> {
+  // We do not need to prompt the user if they do not have Git installed
+  if (!commandExists.sync("git")) {
+    console.log(
+      'Git does not seem to be installed. (The "git" command is not in the path.) Skipping Git-related things.',
+    );
+    return undefined;
+  }
+
+  validateNewGitVersion(verbose);
+
+  const gitHubUsername = getGitHubUsername();
+  if (gitHubUsername !== undefined) {
+    const [exitStatus] = execShell(
+      "gh",
+      ["repo", "view", projectName],
+      verbose,
+      true,
+    );
+    const gitHubRepoExists = exitStatus === 0;
+    const url = `https://github.com/${gitHubUsername}/${projectName}`;
+
+    if (gitHubRepoExists) {
+      console.log(
+        `Detected an existing GitHub repository at: ${chalk.green(url)}`,
+      );
+      const guessedRemoteURL = getGitRemoteURL(projectName, gitHubUsername);
+
+      if (yes) {
+        console.log(
+          `Using a Git remote URL of: ${chalk.green(guessedRemoteURL)}`,
+        );
+        return guessedRemoteURL;
+      }
+
+      const shouldUseGuessedURL = await getInputYesNo(
+        `Do you want to use a Git remote URL of: ${chalk.green(
+          guessedRemoteURL,
+        )}`,
+      );
+      if (shouldUseGuessedURL) {
+        return guessedRemoteURL;
+      }
+
+      // Assume that since they do not want to connect this project to the existing GitHub
+      // repository, they do not want to initialize a remote Git URL at all
+      return undefined;
+    }
+
+    if (yes) {
+      execShell("gh", ["repo", "create", projectName, "--public"]);
+      console.log(`Created a new GitHub repository at: ${url}`);
+      return getGitRemoteURL(projectName, gitHubUsername);
+    }
+
+    const createNewGitHubRepo = await getInputYesNo(
+      `Would you like to create a new GitHub repository at: ${chalk.green(
+        url,
+      )}`,
+    );
+    if (createNewGitHubRepo) {
+      execShell("gh", ["repo", "create", projectName, "--public"]);
+      console.log("Successfully created a new GitHub repository.");
+      return getGitRemoteURL(projectName, gitHubUsername);
+    }
+
+    // Assume that since they do not want to create a new GitHub repository, they do not want to
+    // initialize a remote Git URL at all
+    return undefined;
+  }
+
+  const gitRemoteURL =
+    await getInputString(`Paste in the remote Git URL for your project.
+For example, if you have an SSH key, it would be something like:
+${chalk.green("git@github.com:Alice/green-candle.git")}
+If you don't have an SSH key, it would be something like:
+${chalk.green("https://github.com/Alice/green-candle.git")}
+If you don't want to initialize a Git repository for this project, press enter to skip.
+`);
+
+  return gitRemoteURL === "" ? undefined : gitRemoteURL;
+}
+
+function validateNewGitVersion(verbose: boolean) {
+  const [, stdout] = execShell("git", ["--version"], verbose);
+
+  const outputPrefix = "git version ";
+  if (!stdout.startsWith(outputPrefix)) {
+    error(
+      `Failed to parse the output from the "git --version" command: ${stdout}`,
+    );
+  }
+
+  const gitVersionString = stdout.slice(outputPrefix.length);
+  const [majorVersion, minorVersion] = parseSemVer(gitVersionString);
+
+  if (
+    majorVersion >= REQUIRED_GIT_MAJOR_VERSION &&
+    minorVersion >= REQUIRED_GIT_MINOR_VERSION
+  ) {
+    return;
+  }
+
+  console.error(`Your Git version is: ${chalk.red(gitVersionString)}`);
+  console.error(
+    `${PROJECT_NAME} requires a Git version of ${chalk.red(
+      `${REQUIRED_GIT_MAJOR_VERSION}.${REQUIRED_GIT_MINOR_VERSION}.0`,
+    )} or greater.`,
+  );
+  console.error(
+    `Please upgrade your version of Git before using ${PROJECT_NAME}.`,
+  );
+  process.exit(1);
+}
+
+function getGitHubUsername() {
+  // If the GitHub CLI is installed, we can derive the user's GitHub username
+  if (
+    !commandExists.sync("gh") ||
+    process.env.APPDATA === undefined ||
+    process.env.APPDATA === ""
+  ) {
+    return undefined;
+  }
+
+  const githubCLIHostsPath = path.join(
+    process.env.APPDATA,
+    "GitHub CLI",
+    "hosts.yml",
+  );
+  if (!file.exists(githubCLIHostsPath)) {
+    return undefined;
+  }
+
+  const configYAMLRaw = file.read(githubCLIHostsPath);
+  const configYAML = yaml.parse(configYAMLRaw) as GitHubCLIHostsYAML;
+
+  const githubCom = configYAML["github.com"];
+  if (githubCom === undefined) {
+    return undefined;
+  }
+
+  const { user } = githubCom;
+  if (user === "") {
+    return undefined;
+  }
+
+  return user;
+}
+
+function getGitRemoteURL(projectName: string, gitHubUsername: string) {
+  return `git@github.com:${gitHubUsername}/${projectName}.git`;
+}
+
+export function initGitRepository(
+  projectPath: string,
+  gitRemoteURL: string | undefined,
+  verbose: boolean,
+): void {
+  if (!commandExists.sync("git")) {
+    return;
+  }
+
+  execShell("git", ["init"], verbose, false, projectPath);
+  execShell("git", ["branch", "-M", "main"], verbose, false, projectPath);
+
+  if (isGitNameAndEmailConfigured(verbose)) {
+    execShell("git", ["add", "--all"], verbose, false, projectPath);
+    execShell(
+      "git",
+      ["commit", "--message", `${PROJECT_NAME} template`],
+      verbose,
+      false,
+      projectPath,
+    );
+  }
+
+  if (gitRemoteURL !== undefined) {
+    execShell(
+      "git",
+      ["remote", "add", "origin", gitRemoteURL],
+      verbose,
+      false,
+      projectPath,
+    );
+  }
+}
+
+function isGitNameAndEmailConfigured(verbose: boolean) {
+  const [nameExitStatus] = execShell(
+    "git",
+    ["config", "--global", "user.name"],
+    verbose,
+    true,
+  );
+
+  const [emailExitStatus] = execShell(
+    "git",
+    ["config", "--global", "user.email"],
+    verbose,
+    true,
+  );
+
+  return nameExitStatus === 0 && emailExitStatus === 0;
+}
+
+export function isGitDirty(verbose: boolean): boolean {
+  // From: https://remarkablemark.org/blog/2017/10/12/check-git-dirty/
+  const [, stdout] = execShell("git", ["status", "--porcelain"], verbose);
+  return stdout !== "";
+}
+
+export function gitCommitIfChanges(version: string, verbose: boolean): void {
+  // Throw an error if this is not a git repository
+  execShell("git", ["status"], verbose);
+
+  if (!isGitDirty(verbose)) {
+    console.log("There are no changes to commit.");
+    return;
+  }
+
+  const commitMessage = `v${version}`;
+  execShell("git", ["add", "-A"], verbose);
+  execShell("git", ["commit", "-m", commitMessage], verbose);
+  execShell("git", ["push"], verbose);
+
+  console.log(
+    `Committed and pushed to the git repository with a message of: ${commitMessage}`,
+  );
+}

package/src/commands/init/init.ts

@@ -8,33 +8,48 @@ import { checkModTargetDirectory } from "./checkModTargetDirectory";
 import { createMod } from "./createMod";
 import { getModsDir } from "./getModsDir";
 import { getProjectPath } from "./getProjectPath";
+import { promptGitHubRepoOrGitRemoteURL } from "./git";
 import { installVSCodeExtensions } from "./installVSCodeExtensions";
 import { promptSaveSlot } from "./promptSaveSlot";
 import { promptVSCode } from "./promptVSCode";
 
 export async function init(argv: Record<string, unknown>): Promise<void> {
-  const vscode = argv.vscode === true;
   const skipNPMInstall = argv.skipNpmInstall === true;
+  const useCurrentDir = argv.useCurrentDir === true;
   const verbose = argv.verbose === true;
+  const vscode = argv.vscode === true;
+  const yes = argv.yes === true;
 
   // Prompt the end-user for some information (and validate it as we go)
-  const [projectPath, createNewDir] = await getProjectPath(argv);
-  await checkIfProjectPathExists(projectPath, verbose);
+  const [projectPath, createNewDir] = await getProjectPath(
+    argv,
+    useCurrentDir,
+    yes,
+  );
+  await checkIfProjectPathExists(projectPath, yes, verbose);
   const modsDirectory = await getModsDir(argv);
   checkModSubdirectory(projectPath, modsDirectory);
   const projectName = path.basename(projectPath);
-  await checkModTargetDirectory(modsDirectory, projectName, verbose);
-  const saveSlot = await promptSaveSlot(argv);
+  await checkModTargetDirectory(modsDirectory, projectName, yes, verbose);
+  const saveSlot = await promptSaveSlot(argv, yes);
+  const gitRemoteURL = await promptGitHubRepoOrGitRemoteURL(
+    projectName,
+    yes,
+    verbose,
+  );
 
-  await createMod(
+  // Now that we have asked the user all of the questions we need, we can create the project
+  createMod(
     projectName,
     projectPath,
     createNewDir,
     modsDirectory,
     saveSlot,
+    gitRemoteURL,
     skipNPMInstall,
     verbose,
   );
+
   await openVSCode(projectPath, vscode, verbose);
   printFinishMessage(projectPath, projectName);
 }

package/src/commands/init/promptSaveSlot.ts

@@ -3,6 +3,7 @@ import { error } from "../../utils";
 
 export async function promptSaveSlot(
   argv: Record<string, unknown>,
+  yes: boolean,
 ): Promise<number> {
   if (argv.saveSlot !== undefined) {
     // They specified the "--save-slot" command-line flag,
@@ -10,6 +11,10 @@ export async function promptSaveSlot(
     return argv.saveSlot as number;
   }
 
+  if (yes) {
+    return 1;
+  }
+
   const saveSlot = await getInputInt(
     "In-game, will you test your mod on save slot 1, 2, or 3?",
   );

package/src/commands/monitor/modDirectorySyncer/modDirectorySyncer.ts

@@ -41,12 +41,6 @@ function afterEachSync(params?: {
     return;
   }
 
-  /*
-  if (params.relativePath === path.sep + MAIN_LUA) {
-    monkeyPatchMainLua(modTargetPath);
-  }
-  */
-
   if (params.eventType !== "init:copy") {
     send(`${FILE_SYNCED_MESSAGE} ${params.relativePath}`);
   }

package/src/commands/publish/publish.ts

@@ -17,6 +17,7 @@ import * as file from "../../file";
 import { Config } from "../../types/Config";
 import { error, getModTargetDirectoryName, parseIntSafe } from "../../utils";
 import { compileAndCopy } from "../copy/copy";
+import { gitCommitIfChanges, isGitDirty } from "../init/git";
 
 const UPDATE_SCRIPT_NAME = "update.sh";
 
@@ -289,31 +290,6 @@ function runReleaseScriptPostCopy(verbose: boolean) {
   }
 }
 
-function gitCommitIfChanges(version: string, verbose: boolean) {
-  // Throw an error if this is not a git repository
-  execShell("git", ["status"], verbose);
-
-  if (!isGitDirty(verbose)) {
-    console.log("There are no changes to commit.");
-    return;
-  }
-
-  const commitMessage = `v${version}`;
-  execShell("git", ["add", "-A"], verbose);
-  execShell("git", ["commit", "-m", commitMessage], verbose);
-  execShell("git", ["push"], verbose);
-
-  console.log(
-    `Committed and pushed to the git repository with a message of: ${commitMessage}`,
-  );
-}
-
-function isGitDirty(verbose: boolean) {
-  // From: https://remarkablemark.org/blog/2017/10/12/check-git-dirty/
-  const [, stdout] = execShell("git", ["status", "--porcelain"], verbose);
-  return stdout !== "";
-}
-
 function purgeRoomXMLs(modTargetPath: string, verbose: boolean) {
   const roomsPath = path.join(modTargetPath, "resources", "rooms");
   if (!file.exists(roomsPath) || !file.isDir(roomsPath)) {