isaacscript 1.1.74-dev.3 → 1.2.3

package/src/commands/init/createMod.ts

@@ -19,10 +19,14 @@ import {
   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 { execShell } from "../../util";
+import { error, parseSemVer } from "../../util";
+
+const REQUIRED_GIT_MAJOR_VERSION = 2;
+const REQUIRED_GIT_MINOR_VERSION = 30;
 
 export async function createMod(
   projectName: string,
@@ -31,41 +35,42 @@ export async function createMod(
   modsDirectory: string,
   saveSlot: number,
   skipNPMInstall: boolean,
+  verbose: boolean,
 ): Promise<void> {
   if (createNewDir) {
-    file.makeDir(projectPath);
+    file.makeDir(projectPath, verbose);
   }
 
   const config = configFile.createObject(modsDirectory, saveSlot);
-  configFile.createFile(projectPath, config);
+  configFile.createFile(projectPath, config, verbose);
   const targetModDirectory = path.join(config.modsDirectory, projectName);
 
-  makeSubdirectories(projectPath);
-  copyStaticFiles(projectPath);
-  copyDynamicFiles(projectName, projectPath, targetModDirectory);
-  updateNodeModules(projectPath);
-  await initGitRepository(projectPath, projectName);
-  installNodeModules(projectPath, skipNPMInstall);
+  makeSubdirectories(projectPath, verbose);
+  copyStaticFiles(projectPath, verbose);
+  copyDynamicFiles(projectName, projectPath, targetModDirectory, verbose);
+  updateNodeModules(projectPath, verbose);
+  await initGitRepository(projectPath, projectName, verbose);
+  installNodeModules(projectPath, skipNPMInstall, verbose);
 
   console.log(`Successfully created mod: ${chalk.green(projectName)}`);
 }
 
-function makeSubdirectories(projectPath: string) {
+function makeSubdirectories(projectPath: string, verbose: boolean) {
   // The "src" directory is created during copying of static files
   for (const subdirectory of ["mod"]) {
     const srcPath = path.join(projectPath, subdirectory);
-    file.makeDir(srcPath);
+    file.makeDir(srcPath, verbose);
   }
 }
 
 // Copy static files, like ".eslintrc.js", "tsconfig.json", etc.
-function copyStaticFiles(projectPath: string) {
+function copyStaticFiles(projectPath: string, verbose: boolean) {
   const staticFileList = file.getDirList(TEMPLATES_STATIC_DIR);
   staticFileList.forEach((fileName: string) => {
     const templateFilePath = path.join(TEMPLATES_STATIC_DIR, fileName);
     const destinationFilePath = path.join(projectPath, fileName);
     if (!file.exists(destinationFilePath)) {
-      file.copy(templateFilePath, destinationFilePath);
+      file.copy(templateFilePath, destinationFilePath, verbose);
     }
   });
 }
@@ -75,6 +80,7 @@ function copyDynamicFiles(
   projectName: string,
   projectPath: string,
   targetModDirectory: string,
+  verbose: boolean,
 ) {
   // ".gitignore"
   {
@@ -92,7 +98,7 @@ function copyDynamicFiles(
     const gitignore = gitignoreHeader + template;
 
     const destinationPath = path.join(projectPath, `.${fileName}`); // We need to prepend a period
-    file.write(destinationPath, gitignore);
+    file.write(destinationPath, gitignore, verbose);
   }
 
   // "package.json"
@@ -103,7 +109,7 @@ function copyDynamicFiles(
     const template = file.read(templatePath);
     const packageJSON = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(projectPath, fileName);
-    file.write(destinationPath, packageJSON);
+    file.write(destinationPath, packageJSON, verbose);
   }
 
   // "README.md"
@@ -113,7 +119,7 @@ function copyDynamicFiles(
     const template = file.read(templatePath);
     const readmeMD = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(projectPath, fileName);
-    file.write(destinationPath, readmeMD);
+    file.write(destinationPath, readmeMD, verbose);
   }
 
   // "mod/metadata.xml"
@@ -124,7 +130,7 @@ function copyDynamicFiles(
     const metadataXML = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const modPath = path.join(projectPath, "mod");
     const destinationPath = path.join(modPath, fileName);
-    file.write(destinationPath, metadataXML);
+    file.write(destinationPath, metadataXML, verbose);
   }
 
   // "mod/metadata.vdf"
@@ -135,7 +141,7 @@ function copyDynamicFiles(
     const metadataVDF = template.replace(/MOD_TARGET_DIR/g, targetModDirectory);
     const modPath = path.join(projectPath, "mod");
     const destinationPath = path.join(modPath, fileName);
-    file.write(destinationPath, metadataVDF);
+    file.write(destinationPath, metadataVDF, verbose);
   }
 
   // "src/main.ts"
@@ -148,21 +154,26 @@ function copyDynamicFiles(
     const template = file.read(templatePath);
     const mainTS = template.replace(/MOD_NAME_TO_REPLACE/g, projectName);
     const destinationPath = path.join(srcPath, fileName);
-    file.write(destinationPath, mainTS);
+    file.write(destinationPath, mainTS, verbose);
   }
 }
 
-function updateNodeModules(projectPath: string) {
+function updateNodeModules(projectPath: string, verbose: boolean) {
   console.log("Finding out the latest versions of the NPM packages...");
   execShell(
     "npx",
     ["npm-check-updates", "--upgrade", "--packageFile", "package.json"],
+    verbose,
     false,
     projectPath,
   );
 }
 
-async function initGitRepository(projectPath: string, projectName: string) {
+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.',
@@ -170,19 +181,28 @@ async function initGitRepository(projectPath: string, projectName: string) {
     return;
   }
 
+  checkOldGitVersion(verbose);
+
   const remoteURL = await getGitRemoteURL(projectName);
   if (remoteURL === "") {
     return;
   }
 
-  execShell("git", ["init"], false, projectPath);
-  execShell("git", ["branch", "-M", "main"], false, projectPath);
-  execShell("git", ["remote", "add", "origin", remoteURL], false, projectPath);
-  if (isGitNameAndEmailConfigured()) {
-    execShell("git", ["add", "--all"], false, projectPath);
+  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,
     );
@@ -211,6 +231,38 @@ If you don't want to initialize a Git repository for this project, press enter t
 `);
 }
 
+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) {
@@ -255,27 +307,33 @@ function getGitHubUsername() {
   return user;
 }
 
-function isGitNameAndEmailConfigured() {
+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) {
+function installNodeModules(
+  projectPath: string,
+  skipNPMInstall: boolean,
+  verbose: boolean,
+) {
   if (skipNPMInstall) {
     return;
   }
 
   console.log("Installing node modules... (This can take a long time.)");
-  execShell("npm", ["install"], false, projectPath);
+  execShell("npm", ["install"], verbose, false, projectPath);
 }

package/src/commands/init/init.ts

@@ -13,15 +13,18 @@ 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 verbose = argv.verbose === true;
+
   // Prompt the end-user for some information (and validate it as we go)
   const [projectPath, createNewDir] = await getProjectPath(argv);
-  await checkIfProjectPathExists(projectPath);
+  await checkIfProjectPathExists(projectPath, verbose);
   const modsDirectory = await getModsDir(argv);
   checkModSubdirectory(projectPath, modsDirectory);
   const projectName = path.basename(projectPath);
-  await checkModTargetDirectory(modsDirectory, projectName);
+  await checkModTargetDirectory(modsDirectory, projectName, verbose);
   const saveSlot = await promptSaveSlot(argv);
-  const skipNPMInstall = argv.skipNpmInstall === true;
 
   await createMod(
     projectName,
@@ -30,12 +33,17 @@ export async function init(argv: Record<string, unknown>): Promise<void> {
     modsDirectory,
     saveSlot,
     skipNPMInstall,
+    verbose,
   );
-  await openVSCode(projectPath, argv);
+  await openVSCode(projectPath, vscode, verbose);
   printFinishMessage(projectPath, projectName);
 }
 
-async function openVSCode(projectPath: string, argv: Record<string, unknown>) {
+async function openVSCode(
+  projectPath: string,
+  vscode: boolean,
+  verbose: boolean,
+) {
   const VSCodeCommand = getVSCodeCommand();
   if (VSCodeCommand === null) {
     console.log(
@@ -44,8 +52,8 @@ async function openVSCode(projectPath: string, argv: Record<string, unknown>) {
     return;
   }
 
-  installVSCodeExtensions(projectPath, VSCodeCommand);
-  await promptVSCode(projectPath, argv, VSCodeCommand);
+  installVSCodeExtensions(projectPath, VSCodeCommand, verbose);
+  await promptVSCode(projectPath, VSCodeCommand, vscode, verbose);
 }
 
 function getVSCodeCommand() {

package/src/commands/init/installVSCodeExtensions.ts

@@ -1,16 +1,18 @@
 import chalk from "chalk";
 import * as JSONC from "jsonc-parser";
 import path from "path";
+import { execShell } from "../../exec";
 import * as file from "../../file";
-import { error, execShell } from "../../util";
+import { error } from "../../util";
 
 export function installVSCodeExtensions(
   projectPath: string,
   VSCodeCommand: string,
+  verbose: boolean,
 ): void {
   const extensions = getExtensionsFromJSON(projectPath);
   for (const extensionName of extensions) {
-    execShell(VSCodeCommand, ["--install-extension", extensionName]);
+    execShell(VSCodeCommand, ["--install-extension", extensionName], verbose);
   }
 }
 

package/src/commands/init/promptVSCode.ts

@@ -1,17 +1,18 @@
 import path from "path";
 import { MAIN_TS } from "../../constants";
+import { execShell } from "../../exec";
 import { getInputYesNo } from "../../prompt";
-import { execShell } from "../../util";
 
 export async function promptVSCode(
   projectPath: string,
-  argv: Record<string, unknown>,
   VSCodeCommand: string,
+  vscode: boolean,
+  verbose: boolean,
 ): Promise<void> {
-  if (argv.vscode !== undefined) {
+  if (vscode) {
     // They supplied the "--vscode" command-line flag,
     // so there is no need to prompt the user
-    openVSCode(projectPath, VSCodeCommand);
+    openVSCode(projectPath, VSCodeCommand, verbose);
     return;
   }
 
@@ -19,11 +20,15 @@ export async function promptVSCode(
     "Do you want to open your new project in VSCode now?",
   );
   if (shouldOpenVSCode) {
-    openVSCode(projectPath, VSCodeCommand);
+    openVSCode(projectPath, VSCodeCommand, verbose);
   }
 }
 
-function openVSCode(projectPath: string, VSCodeCommand: string) {
+function openVSCode(
+  projectPath: string,
+  VSCodeCommand: string,
+  verbose: boolean,
+) {
   const MAIN_TS_PATH = path.join(projectPath, "src", MAIN_TS);
-  execShell(VSCodeCommand, [projectPath, MAIN_TS_PATH]);
+  execShell(VSCodeCommand, [projectPath, MAIN_TS_PATH], verbose);
 }

package/src/commands/monitor/copyWatcherMod.ts

@@ -8,7 +8,7 @@ import {
 import * as file from "../../file";
 import { Config } from "../../types/Config";
 
-export function copyWatcherMod(config: Config): void {
+export function copyWatcherMod(config: Config, verbose: boolean): void {
   // Check to see if this mod was disabled
   const watcherModPath = path.join(config.modsDirectory, WATCHER_MOD_NAME);
   const disableItPath = path.join(watcherModPath, DISABLE_IT_FILE);
@@ -17,21 +17,21 @@ export function copyWatcherMod(config: Config): void {
   // Delete and re-copy the watcher mod every time IsaacScript starts
   // This ensures that it is always the latest version
   if (file.exists(watcherModPath)) {
-    file.deleteFileOrDirectory(watcherModPath);
+    file.deleteFileOrDirectory(watcherModPath, verbose);
   }
 
-  file.copy(WATCHER_MOD_SOURCE_PATH, watcherModPath);
+  file.copy(WATCHER_MOD_SOURCE_PATH, watcherModPath, verbose);
 
   if (watcherModDisabled) {
     // Since we deleted the directory, the "disable.it" file was deleted
     // Restore it
-    file.write(disableItPath, "");
+    file.write(disableItPath, "", verbose);
   }
 
   // By default, the IsaacScript watcher mod automatically restarts the game,
   // so we only need to disable it if the config option is explicitly set to false
   if (config.enableIsaacScriptWatcherAutoRestart === false) {
-    disableIsaacScriptWatcherAutomaticRestart(watcherModPath);
+    disableIsaacScriptWatcherAutomaticRestart(watcherModPath, verbose);
   }
 
   // If we copied a new version of the watcher mod into place,
@@ -40,7 +40,10 @@ export function copyWatcherMod(config: Config): void {
   // so there is no automated solution for this
 }
 
-function disableIsaacScriptWatcherAutomaticRestart(watcherModPath: string) {
+function disableIsaacScriptWatcherAutomaticRestart(
+  watcherModPath: string,
+  verbose: boolean,
+) {
   const mainLuaPath = path.join(watcherModPath, MAIN_LUA);
   const mainLua = file.read(mainLuaPath);
 
@@ -49,5 +52,5 @@ function disableIsaacScriptWatcherAutomaticRestart(watcherModPath: string) {
     "local RESTART_GAME_ON_RECOMPILATION = false",
   );
 
-  file.write(mainLuaPath, modifiedMainLua);
+  file.write(mainLuaPath, modifiedMainLua, verbose);
 }

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

@@ -1,7 +1,5 @@
-import path from "path";
 import syncDirectory from "sync-directory";
-import { FILE_SYNCED_MESSAGE, MAIN_LUA } from "../../../constants";
-import { monkeyPatchMainLua } from "../../../monkeyPatch";
+import { FILE_SYNCED_MESSAGE } from "../../../constants";
 
 let modSourcePath: string;
 let modTargetPath: string;
@@ -43,9 +41,11 @@ 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/monitor/monitor.ts

@@ -19,6 +19,8 @@ import { spawnSaveDatWriter } from "./spawnSaveDatWriter";
 import { touchWatcherSaveDatFiles } from "./touchWatcherSaveDatFiles";
 
 export function monitor(argv: Record<string, unknown>, config: Config): void {
+  const verbose = argv.verbose === true;
+
   // If they specified some command-line flags, override the values found in the config file
   if (argv.modsDirectory !== undefined) {
     config.modsDirectory = argv.modsDirectory as string; // eslint-disable-line no-param-reassign
@@ -34,13 +36,13 @@ export function monitor(argv: Record<string, unknown>, config: Config): void {
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
 
   // Prepare the IsaacScript watcher mod
-  copyWatcherMod(config);
-  touchWatcherSaveDatFiles(config);
+  copyWatcherMod(config, verbose);
+  touchWatcherSaveDatFiles(config, verbose);
 
   // Delete and re-copy the mod every time IsaacScript starts
   // This ensures that it is always the latest version
   if (file.exists(modTargetPath)) {
-    file.deleteFileOrDirectory(modTargetPath);
+    file.deleteFileOrDirectory(modTargetPath, true);
   }
 
   // Subprocess #1 - The "save#.dat" file writer

package/src/commands/monitor/saveDatWriter/saveDatWriter.ts

@@ -27,7 +27,7 @@ function init() {
   // Check to see if the data directory exists
   const watcherModDataPath = path.dirname(saveDatPath);
   if (!file.exists(watcherModDataPath)) {
-    file.makeDir(watcherModDataPath);
+    file.makeDir(watcherModDataPath, false);
   }
 
   // Listen for messages from the parent process

package/src/commands/monitor/touchWatcherSaveDatFiles.ts

@@ -3,15 +3,18 @@ import { WATCHER_MOD_NAME } from "../../constants";
 import * as file from "../../file";
 import { Config } from "../../types/Config";
 
-export function touchWatcherSaveDatFiles(config: Config): void {
+export function touchWatcherSaveDatFiles(
+  config: Config,
+  verbose: boolean,
+): void {
   const modsDataPath = path.join(config.modsDirectory, "..", "data");
   const watcherModDataPath = path.join(modsDataPath, WATCHER_MOD_NAME);
   if (!file.exists(watcherModDataPath)) {
-    file.makeDir(watcherModDataPath);
+    file.makeDir(watcherModDataPath, verbose);
   }
   const saveDatFileName = `save${config.saveSlot}.dat`;
   const saveDatPath = path.join(watcherModDataPath, saveDatFileName);
   if (!file.exists(saveDatPath)) {
-    file.touch(saveDatPath);
+    file.touch(saveDatPath, verbose);
   }
 }