Allow generating new exercises in nested directories

Exercises dirs will no longer all be in the repo root but will be nested
in dirs relating to the curriculum structure.

Author: mao-sz

generators/helpers.js

@@ -1,30 +1,56 @@
 const { readdir } = require("fs/promises");
+const { basename, dirname, join } = require("path");
 
 function splitDirectoryName(directoryName) {
+  const exerciseDirectoryName = directoryName.endsWith("solution")
+    ? basename(dirname(directoryName))
+    : basename(directoryName);
   return {
-    exerciseNumber: directoryName.match(/\d+/),
-    exerciseName: directoryName.match(/[a-z]+/i),
+    exerciseNumber: exerciseDirectoryName.match(/\d+/),
+    exerciseName: exerciseDirectoryName.match(/[a-z]+/i),
   };
 }
 
-async function getLatestExerciseDirectory() {
+async function getDirsWithExercises(path) {
+  const ignoredDirs = ["archive", "node_modules", "generators"];
   try {
-    const files = await readdir("./");
+    const dirs = await readdir(join(process.cwd(), path), {
+      withFileTypes: true,
+    });
+    const exerciseDirs = dirs.filter(
+      (entry) =>
+        entry.isDirectory() &&
+        !entry.name.startsWith(".") &&
+        !ignoredDirs.includes(entry.name),
+    );
+    return exerciseDirs.map((dir) => dir.name);
+  } catch {
+    return [];
+  }
+}
+
+async function getLatestExerciseDirectory(path) {
+  try {
+    const files = await readdir(join(process.cwd(), path));
     return files.findLast((file) => /^\d+_\w+$/.test(file));
-  } catch (err) {
-    console.error(err);
+  } catch {
+    return "0";
   }
 }
 
-async function createExerciseDirectoryName(directoryName) {
-  const latestExerciseDirectory = await getLatestExerciseDirectory();
+async function createExerciseDirectoryName(exerciseName, path) {
+  const latestExerciseDirectory = await getLatestExerciseDirectory(path);
   const latestExerciseNumber = parseInt(latestExerciseDirectory.match(/^\d+/));
 
-  if (latestExerciseDirectory === `${latestExerciseNumber}_${directoryName}`) {
-    throw new Error(`Exercise already exists with name "${directoryName}"`);
+  if (latestExerciseDirectory === `${latestExerciseNumber}_${exerciseName}`) {
+    throw new Error(`Exercise already exists with name "${exerciseName}"`);
   }
 
-  return `${latestExerciseNumber + 1}_${directoryName}`;
+  return `${latestExerciseNumber + 1}_${exerciseName}`;
 }
 
-module.exports = { createExerciseDirectoryName, splitDirectoryName };
+module.exports = {
+  getDirsWithExercises,
+  createExerciseDirectoryName,
+  splitDirectoryName,
+};

plopFile.js

@@ -1,46 +1,103 @@
 const { mkdir } = require("fs/promises");
 const { join } = require("path");
 const { camelCase } = require("case-anything");
-const { createExerciseDirectoryName } = require("./generators/helpers");
+const {
+  createExerciseDirectoryName,
+  getDirsWithExercises,
+} = require("./generators/helpers");
 const { writeReadme } = require("./generators/writeReadme");
 const { writeExercise } = require("./generators/writeExercise");
 const { writeExerciseSpec } = require("./generators/writeExerciseSpec");
 
+/**
+ * @typedef {import('plop').NodePlopAPI} Plop
+ * @param {Plop} plop
+ */
 module.exports = function (plop) {
-  plop.setActionType("createExercise", async function (answers) {
-    const { exerciseName } = answers;
-    if (!exerciseName) {
-      throw new Error(
-        `Invalid exerciseName. Expected: valid string. Actual: "${exerciseName}"`
+  const NEW_DIR_OPTION = "<Make new directory>";
+
+  plop.setActionType(
+    "createExercise",
+    async function ({ pathForExercise, exerciseName }) {
+      if (!exerciseName) {
+        throw new Error(
+          `Invalid exerciseName. Expected: valid string. Actual: "${exerciseName}"`,
+        );
+      } else if (!pathForExercise.length) {
+        throw new Error(
+          "The new exercise cannot be placed in the project root",
+        );
+      }
+
+      const camelExerciseName = camelCase(exerciseName);
+      const exerciseDirectoryName = await createExerciseDirectoryName(
+        camelExerciseName,
+        join(...pathForExercise),
       );
-    }
-
-    const camelExerciseName = camelCase(exerciseName);
-    const exerciseDirectoryName = await createExerciseDirectoryName(
-      camelExerciseName
-    );
-    const basePath = join("./", exerciseDirectoryName);
-    const solutionPath = join(basePath, "solution");
-
-    await mkdir(basePath);
-    await mkdir(solutionPath);
-
-    await writeReadme(basePath);
-    await writeExercise(basePath);
-    await writeExercise(solutionPath);
-    await writeExerciseSpec(basePath);
-    await writeExerciseSpec(solutionPath);
-  });
+      const basePath = join(
+        process.cwd(),
+        ...pathForExercise,
+        exerciseDirectoryName,
+      );
+      const solutionPath = join(basePath, "solution");
+
+      await mkdir(basePath, { recursive: true });
+      await mkdir(solutionPath);
+
+      await writeReadme(basePath);
+      await writeExercise(basePath);
+      await writeExercise(solutionPath);
+      await writeExerciseSpec(basePath);
+      await writeExerciseSpec(solutionPath);
+    },
+  );
 
   plop.setGenerator("Basic", {
     description: "Create a basic JavaScript exercise.",
-    prompts: [
-      {
+    prompts: async function (inquirer) {
+      async function getPathForExercise(dirPath = []) {
+        const exerciseDirs = await getDirsWithExercises(dirPath.join("/"));
+
+        // Will only be empty when entering a new dir on a recursive call
+        // Recursive call only happens when new dir required which can bypass this question
+        const { dir } = exerciseDirs.length
+          ? await inquirer.prompt({
+              type: "list",
+              name: "dir",
+              message: "Which directory should this exercise go in?",
+              choices: [NEW_DIR_OPTION, ...exerciseDirs],
+            })
+          : { dir: NEW_DIR_OPTION };
+
+        if (dir === NEW_DIR_OPTION) {
+          const { newDirName } = await inquirer.prompt({
+            type: "input",
+            name: "newDirName",
+            message: "What is the name of the new directory?",
+          });
+          dirPath.push(newDirName);
+        } else {
+          dirPath.push(dir);
+        }
+
+        const { needMoreDirs } = await inquirer.prompt({
+          type: "confirm",
+          name: "needMoreDirs",
+          message: "Does this exercise need to be nested in a subdirectory?",
+        });
+
+        return needMoreDirs ? await getPathForExercise(dirPath) : dirPath;
+      }
+
+      const pathForExercise = await getPathForExercise();
+      const { exerciseName } = await inquirer.prompt({
         type: "input",
         name: "exerciseName",
-        message: "What is the name of the exercise? (camelCase)",
-      },
-    ],
+        message: "What is the name of the new exercise (in camelCase)?",
+      });
+
+      return { pathForExercise, exerciseName };
+    },
     actions: [{ type: "createExercise" }],
   });
 };