feat: Add ability to customise type displays

Author: Sidnioulz

README.md

@@ -279,6 +279,43 @@ export default function (plop) {
 	});
 };
 ```
+## setActionTypeDisplay
+`setActionTypeDisplay` allows you to change the characters shown on the output of a specific action. For instance, the `add` action's output is prefixed with `++`.
+
+You may need to write a custom action that fetches a file from an API and adds it, and you may want to use the `++` prefix for consistency. This could be done with the following:
+
+``` javascript
+import chalk from 'chalk';
+
+export default function (plop) {
+	// Define your custom action that asynchronously adds a file
+	plop.setActionType('fetchAndAddAsync', function (answers, config, plop) {
+		return new Promise((resolve, reject) => {
+			if (success) {
+				resolve('success status message');
+			} else {
+				reject('error message');
+			}
+		});
+	});
+
+	// Use the same action type as 'add' for consistency
+	plop.setActionTypeDisplay('fetchAndAddAsync', chalk.green('++'));
+};
+```
+
+By default, the following type displays are set:
+
+``` javascript
+const typeDisplay = {
+  function: chalk.yellow("->"),
+  add: chalk.green("++"),
+  addMany: chalk.green("+!"),
+  modify: `${chalk.green("+")}${chalk.red("-")}`,
+  append: chalk.green("_+"),
+  skip: chalk.green("--"),
+};
+```
 
 ## setPrompt
 [Inquirer](https://github.com/SBoudrias/Inquirer.js/blob/master/packages/inquirer/README.md) provides many types of prompts out of the box, but it also allows developers to build prompt plugins. If you'd like to use a prompt plugin, you can register it with `setPrompt`. For more details see the [Inquirer documentation for registering prompts](https://github.com/SBoudrias/Inquirer.js/blob/master/packages/inquirer/README.md#inquirerregisterpromptname-prompt). Also check out the [plop community driven list of custom prompts](https://github.com/plopjs/awesome-plop#inquirer-prompts).

packages/node-plop/src/node-plop.js

@@ -21,11 +21,12 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
   const generators = {};
   const partials = {};
   const actionTypes = {};
+  const actionTypeDisplays = {};
   const helpers = Object.assign(
     {
       pkg: (propertyPath) => _get(pkgJson, propertyPath, ""),
     },
-    bakedInHelpers,
+    bakedInHelpers
   );
   const baseHelpers = Object.keys(helpers);
 
@@ -39,16 +40,19 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
   const setPartial = (name, str) => {
     partials[name] = str;
   };
+  const setActionTypeDisplay = (name, typeDisplay) => {
+    actionTypeDisplays[name] = typeDisplay;
+  };
   const setActionType = (name, fn) => {
     actionTypes[name] = fn;
   };
 
   function renderString(template, data) {
     Object.keys(helpers).forEach((h) =>
-      handlebars.registerHelper(h, helpers[h]),
+      handlebars.registerHelper(h, helpers[h])
     );
     Object.keys(partials).forEach((p) =>
-      handlebars.registerPartial(p, partials[p]),
+      handlebars.registerPartial(p, partials[p])
     );
     return handlebars.compile(template)(data);
   }
@@ -57,6 +61,7 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
   const getHelper = (name) => helpers[name];
   const getPartial = (name) => partials[name];
   const getActionType = (name) => actionTypes[name];
+  const getActionTypeDisplay = (name) => actionTypeDisplays[name];
   const getGenerator = (name) => generators[name];
   function setGenerator(name = "", config = {}) {
     // if no name is provided, use a default
@@ -75,6 +80,7 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
     Object.keys(helpers).filter((h) => !baseHelpers.includes(h));
   const getPartialList = () => Object.keys(partials);
   const getActionTypeList = () => Object.keys(actionTypes);
+  const getActionTypeDisplayList = () => Object.keys(actionTypeDisplays);
   function getGeneratorList() {
     return Object.keys(generators).map(function (name) {
       const { description } = generators[name];
@@ -103,7 +109,7 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
       {
         destBasePath: getDestBasePath(),
       },
-      loadCfg,
+      loadCfg
     );
 
     await Promise.all(
@@ -118,36 +124,43 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
             helpers: false,
             partials: false,
             actionTypes: false,
+            actionTypeDisplays: false,
           },
-          includeCfg,
+          includeCfg
         );
 
         const genNameList = proxy.getGeneratorList().map((g) => g.name);
         loadAsset(
           genNameList,
           includeCfg === true || include.generators,
           setGenerator,
-          (proxyName) => ({ proxyName, proxy }),
+          (proxyName) => ({ proxyName, proxy })
         );
         loadAsset(
           proxy.getPartialList(),
           includeCfg === true || include.partials,
           setPartial,
-          proxy.getPartial,
+          proxy.getPartial
         );
         loadAsset(
           proxy.getHelperList(),
           includeCfg === true || include.helpers,
           setHelper,
-          proxy.getHelper,
+          proxy.getHelper
         );
         loadAsset(
           proxy.getActionTypeList(),
           includeCfg === true || include.actionTypes,
           setActionType,
-          proxy.getActionType,
+          proxy.getActionType
+        );
+        loadAsset(
+          proxy.getActionTypeDisplayList(),
+          includeCfg === true || include.actionTypeDisplays,
+          setActionTypeDisplay,
+          proxy.getActionTypeDisplay
         );
-      }),
+      })
     );
   }
 
@@ -202,6 +215,9 @@ async function nodePlop(plopfilePath = "", plopCfg = {}) {
     setActionType,
     getActionType,
     getActionTypeList,
+    setActionTypeDisplay,
+    getActionTypeDisplay,
+    getActionTypeDisplayList,
 
     // path context methods
     setPlopfilePath,

packages/node-plop/tests/imported-custom-action/imported-custom-action.spec.js

@@ -62,4 +62,24 @@ describe("imported-custom-action", function () {
       true,
     );
   });
+
+  test("imported custom action can define a custom type display string", async function () {
+    const plop = await nodePlop();
+    const testFilePath = path.resolve(testSrcPath, "test.txt");
+    plop.setActionType("custom-del", customAction);
+    plop.setActionTypeDisplay("custom-del", "><");
+
+    // add the file
+    const addTestFile = { type: "add", path: testFilePath };
+    // remove the file
+    const deleteTestFile = { type: "custom-del", path: testFilePath };
+
+    const generator = plop.setGenerator("", {
+      actions: [addTestFile, deleteTestFile],
+    });
+
+    expect(typeof plop.getActionType("custom-del")).toBe("function");
+    expect(typeof plop.getActionTypeDisplay("custom-del")).toBe("string");
+    expect(plop.getActionTypeDisplay("custom-del")).toBe("><");
+  });
 });

packages/node-plop/tests/load-assets-from-plopfile/load-assets-from-plopfile.spec.js

@@ -57,7 +57,7 @@ describe("load-assets-from-plopfile", function () {
           generator1: "gen1",
           generator3: "bob",
         },
-      },
+      }
     );
 
     const gNameList = plop.getGeneratorList().map((g) => g.name);
@@ -79,18 +79,27 @@ describe("load-assets-from-plopfile", function () {
         helpers: true,
         partials: true,
         actionTypes: true,
-      },
+        actionTypeDisplays: true,
+      }
     );
 
     const gNameList = plop.getGeneratorList().map((g) => g.name);
     expect(gNameList.length).toBe(3);
     expect(plop.getHelperList().length).toBe(3);
     expect(plop.getPartialList().length).toBe(3);
-    expect(plop.getActionTypeList().length).toBe(1);
+    expect(plop.getActionTypeList().length).toBe(2);
+    expect(plop.getActionTypeDisplayList().length).toBe(1);
     expect(gNameList.includes("test-generator1")).toBe(true);
     expect(plop.getHelperList().includes("test-helper2")).toBe(true);
     expect(plop.getPartialList().includes("test-partial3")).toBe(true);
     expect(plop.getActionTypeList().includes("test-actionType1")).toBe(true);
+    expect(plop.getActionTypeList().includes("test-actionType2")).toBe(true);
+    expect(plop.getActionTypeDisplayList().includes("test-actionType1")).toBe(
+      false
+    );
+    expect(plop.getActionTypeDisplayList().includes("test-actionType2")).toBe(
+      true
+    );
   });
 
   test("plop.load passes a config option that can be used to include all the plopfile output", async function () {
@@ -101,11 +110,19 @@ describe("load-assets-from-plopfile", function () {
     expect(gNameList.length).toBe(3);
     expect(plop.getHelperList().length).toBe(3);
     expect(plop.getPartialList().length).toBe(3);
-    expect(plop.getActionTypeList().length).toBe(1);
+    expect(plop.getActionTypeList().length).toBe(2);
+    expect(plop.getActionTypeDisplayList().length).toBe(1);
     expect(gNameList.includes("test-generator1")).toBe(true);
     expect(plop.getHelperList().includes("test-helper2")).toBe(true);
     expect(plop.getPartialList().includes("test-partial3")).toBe(true);
     expect(plop.getActionTypeList().includes("test-actionType1")).toBe(true);
+    expect(plop.getActionTypeList().includes("test-actionType2")).toBe(true);
+    expect(plop.getActionTypeDisplayList().includes("test-actionType1")).toBe(
+      false
+    );
+    expect(plop.getActionTypeDisplayList().includes("test-actionType2")).toBe(
+      true
+    );
   });
 
   test("plop.load should import functioning assets", async function () {
@@ -118,12 +135,13 @@ describe("load-assets-from-plopfile", function () {
         helpers: true,
         partials: true,
         actionTypes: true,
-      },
+      }
     );
 
     expect(plop.getHelper("test-helper2")("test")).toBe("helper 2: test");
     expect(plop.getPartial("test-partial3")).toBe("partial 3: {{name}}");
     expect(plop.getActionType("test-actionType1")()).toBe("test");
+    expect(plop.getActionType("test-actionType2")()).toBe("test");
   });
 
   test("plop.load can include only helpers", async function () {

packages/node-plop/tests/load-assets-from-plopfile/plopfile.js

@@ -10,6 +10,8 @@ export default function (plop, config = {}) {
   plop.setPartial(`${cfg.prefix}partial3`, "partial 3: {{name}}");
 
   plop.setActionType(`${cfg.prefix}actionType1`, () => "test");
+  plop.setActionType(`${cfg.prefix}actionType2`, () => "test");
+  plop.setActionTypeDisplay(`${cfg.prefix}actionType2`, "><");
 
   const generatorObject = {
     actions: [{ type: "add", path: "src/{{name}}.txt" }],

packages/plop/bin/plop.js

@@ -133,6 +133,11 @@ const typeDisplay = {
   append: chalk.green("_+"),
   skip: chalk.green("--"),
 };
+
+const addToTypeDisplay = (name, characters) => {
+  typeDisplay[name] = characters;
+};
+
 const typeMap = (name, noMap) => {
   const dimType = chalk.dim(name);
   return noMap ? dimType : typeDisplay[name] || dimType;
@@ -142,6 +147,7 @@ export {
   chooseOptionFromList,
   displayHelpScreen,
   createInitPlopfile,
+  addToTypeDisplay,
   typeMap,
   getHelpMessage,
 };

packages/plop/src/console-out.js

@@ -68,6 +68,10 @@ async function run(env, _, passArgsBeforeDashes) {
     plop,
     passArgsBeforeDashes,
   );
+  const actionTypeDisplays = plop.getActionTypeDisplayList();
+  actionTypeDisplays.forEach((type) => {
+    out.addToTypeDisplay(type, plop.getActionTypeDisplay(type));
+  });
 
   // look up a generator and run it with calculated bypass data
   const runGeneratorByName = (name) => {

packages/plop/src/plop.js

@@ -27,6 +27,7 @@ test("Plop to add and rename files", async () => {
   const data = fs.readFileSync(expectedFilePath, "utf8");
 
   expect(data).toMatch(/Hello/);
+  expect(await findByText("++ /output/new-output.txt")).toBeInTheConsole();
 });
 
 test("Plop to add and change file contents", async () => {
@@ -48,9 +49,24 @@ test("Plop to add and change file contents", async () => {
   const data = await fs.promises.readFile(expectedFilePath, "utf8");
 
   expect(data).toMatch(/Hi Corbin!/);
+  expect(await findByText("++ /output/new-output.txt")).toBeInTheConsole();
 });
 
 test.todo("Test modify");
 test.todo("Test append");
 test.todo("Test built-in helpers");
 test.todo("Test custom helpers");
+
+test("Plop to display a custom string for a given action type", async () => {
+  const expectedFilePath = await getFilePath(
+    "./examples/custom-action-display/output/out.txt"
+  );
+
+  const { findByText } = await renderPlop(["addFile"], {
+    cwd: resolve(__dirname, "./examples/custom-action-display"),
+  });
+
+  await waitFor(() => fs.promises.stat(expectedFilePath));
+
+  expect(await findByText(">< /output/out.txt")).toBeInTheConsole();
+});