Action to replace file content

src/actions/index.js

@@ -3,3 +3,4 @@ export { default as moveAction } from './move.js';
 export { default as deleteAction } from './delete.js';
 export { default as mkdirAction } from './mkdir.js';
 export { default as archiveAction } from './archive.js';
+export { default as replaceAction } from './replace.js';

src/actions/replace.js

@@ -0,0 +1,39 @@
+import fs, { existsSync } from 'fs';
+import pExec from '../utils/p-exec.js';
+
+const replaceAction = async (tasks, options) => {
+  const { runTasksInSeries, logger } = options;
+
+  logger.debug(`processing replace tasks. tasks: ${tasks}`);
+
+  await pExec(runTasksInSeries, tasks, async (task) => {
+    const file = task.source;
+
+    if (existsSync(file)) {
+      fs.readFile(file, 'utf8', function (err, data) {
+        if (err) {
+          logger.error(`unable to read ${file}, ${err}`);
+        }
+
+        task.mutations.forEach((mutation) => {
+          let iterations = mutation.iterations ? mutation.iterations : 1;
+          for (let index = 0; index < iterations; index++) {
+            data = data.replace(mutation.pattern, mutation.replacement);
+          }
+        });
+
+        fs.writeFile(file, data, 'utf8', function (err) {
+          if (err) {
+            logger.error(`unable to write ${file}, ${err}`);
+          }
+        });
+      });
+    } else {
+      logger.error(`unable to find ${file}`);
+    }
+  });
+
+  logger.debug(`replace tasks complete. tasks: ${tasks}`);
+};
+
+export default replaceAction;

src/index.js

@@ -4,7 +4,7 @@ import normalizePath from 'normalize-path';
 
 import optionsSchema from './options-schema.js';
 import pExec from './utils/p-exec.js';
-import { copyAction, moveAction, mkdirAction, archiveAction, deleteAction } from './actions/index.js';
+import { copyAction, moveAction, mkdirAction, archiveAction, replaceAction, deleteAction } from './actions/index.js';
 
 const PLUGIN_NAME = 'FileManagerPlugin';
 
@@ -99,6 +99,10 @@ class FileManagerPlugin {
           await this.applyAction(archiveAction, action);
           break;
 
+        case 'replace':
+          await this.applyAction(replaceAction, action);
+          break;
+
         default:
           throw Error('Unknown action');
       }

src/options-schema.js

@@ -147,6 +147,29 @@ export default {
         },
       ],
     },
+    Replace: {
+      description: 'Replace files.',
+      type: 'array',
+      additionalItems: true,
+      items: [
+        {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            source: {
+              description: 'Source. A file.',
+              type: 'string',
+              minLength: 1,
+            },
+            mutations: {
+              description: 'Multiple terms to find and replace. Multiple times (Optional).',
+              type: 'array',
+              minLength: 1,
+            },
+          },
+        },
+      ],
+    },
     Actions: {
       type: 'object',
       additionalProperties: false,
@@ -166,6 +189,9 @@ export default {
         archive: {
           $ref: '#/definitions/Archive',
         },
+        replace: {
+          $ref: '#/definitions/Replace',
+        },
       },
     },
   },

tests/replace.test.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs';
+import test from 'ava';
+import del from 'del';
+import compile from './utils/compile.js';
+import getCompiler from './utils/getCompiler.js';
+import tempy from './utils/tempy.js';
+import FileManagerPlugin from '../src/index.js';
+
+test.beforeEach(async (t) => {
+  t.context.tmpdir = await tempy.dir({ suffix: 'replace-action' });
+});
+
+test.afterEach(async (t) => {
+  await del(t.context.tmpdir);
+});
+
+const matchFileContent = async (pattern, file) => {
+  const data = readFile(file, 'utf-8', function (err, data) {
+    return data;
+  });
+
+  return data !== pattern;
+};
+
+test('should replace the given patterns in given files', async (t) => {
+  const { tmpdir } = t.context;
+  const dir = await tempy.dir({ root: tmpdir });
+  const file = await tempy.file(dir, 'file');
+
+  const config = {
+    context: tmpdir,
+    events: {
+      onEnd: {
+        replace: [
+          {
+            source: file,
+            mutations: [
+              {
+                pattern: 'lorem-ipsum',
+                replacement: 'lorem.ipsum',
+              },
+              {
+                pattern: 'm',
+                replacement: 'n',
+                iterations: 2
+              },
+            ],
+          }
+        ],
+      },
+    },
+  };
+
+  const compiler = getCompiler();
+  new FileManagerPlugin(config).apply(compiler);
+  await compile(compiler);
+
+  t.true(await matchFileContent('loren.ipsun', file))
+});

types.d.ts

@@ -58,6 +58,23 @@ type Archive = {
   options?: ArchiverOptions | { globOptions: ReaddirGlobOptions };
 }[];
 
+/** Replace files content */
+type Replace = {
+  /** File source. */
+  source: string;
+  /** Changes you want to make. */
+  mutations: Mutations[];
+}[];
+
+interface Mutations {
+  /** Pattern to find. */
+  pattern: string;
+  /** Term to replace in file. */
+  replacement: string;
+  /** Number of iterations for mutiple patterns. */
+  iterations?: number;
+}
+
 /** {@link https://github.com/Yqnn/node-readdir-glob#options} */
 interface ReaddirGlobOptions {
   /** Glob pattern or Array of Glob patterns to match the found files with. A file has to match at least one of the provided patterns to be returned. */
@@ -92,6 +109,7 @@ interface Actions {
   move?: Move;
   mkdir?: Mkdir;
   archive?: Archive;
+  replace?: Replace;
 }
 
 interface Options {