mem-fs-editor 9.2.0 → 9.5.0

package/README.md

@@ -1,17 +1,21 @@
-# mem-fs-editor [![Node.js CI](https://github.com/SBoudrias/mem-fs-editor/workflows/Node.js%20CI/badge.svg)](https://github.com/SBoudrias/mem-fs-editor/actions?query=workflow%3A%22Node.js+CI%22) [![NPM version](https://badge.fury.io/js/mem-fs-editor.svg)](http://badge.fury.io/js/mem-fs-editor) [![Coverage Status](https://coveralls.io/repos/github/SBoudrias/mem-fs-editor/badge.svg)](https://coveralls.io/github/SBoudrias/mem-fs-editor)
+# mem-fs-editor
+
+[![Node.js CI](https://github.com/SBoudrias/mem-fs-editor/workflows/Node.js%20CI/badge.svg)](https://github.com/SBoudrias/mem-fs-editor/actions?query=workflow%3A%22Node.js+CI%22)
+[![NPM version](https://badge.fury.io/js/mem-fs-editor.svg)](http://badge.fury.io/js/mem-fs-editor)
+[![Coverage Status](https://codecov.io/gh/SBoudrias/mem-fs-editor/branch/master/graph/badge.svg)](https://codecov.io/gh/SBoudrias/mem-fs-editor)
 
 File edition helpers working on top of [mem-fs](https://github.com/SBoudrias/mem-fs)
 
 ## Usage
 
 ```js
-var memFs = require("mem-fs");
-var editor = require("mem-fs-editor");
+import memFs from 'mem-fs';
+import editor from 'mem-fs-editor';
 
-var store = memFs.create();
-var fs = editor.create(store);
+const store = memFs.create();
+const fs = editor.create(store);
 
-fs.write("somefile.js", "var a = 1;");
+fs.write('somefile.js', 'var a = 1;');
 ```
 
 ### `#read(filepath, [options])`
@@ -142,3 +146,9 @@ If provided, `filters` is an array of TransformStream to be applied on a stream
 If provided, `stream` is a stream of vinyl files.
 
 `callback` is called once the files are updated on disk.
+
+### `#dump([cwd,] [filter])`
+
+Dump files to compare expected result.
+Provide a `cwd` for relative path. Allows to omit temporary path.
+Provide a `filter` function or glob to focus on specific files.

package/lib/actions/append-tpl.js

@@ -1,17 +1,10 @@
 'use strict';
 
-const ejs = require('ejs');
+const { render } = require('../util');
 
 module.exports = function (to, contents, context, tplSettings, options) {
   context = context || {};
   tplSettings = tplSettings || {};
 
-  this.append(
-    to,
-    ejs.render(
-      contents.toString(),
-      context,
-      tplSettings,
-    ),
-    options);
+  this.append(to, render(contents.toString(), context, tplSettings), options);
 };

package/lib/actions/append.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {EOL} = require('os');
+const { EOL } = require('os');
 
 module.exports = function (to, contents, options) {
   options = {

package/lib/actions/commit-file-async.js

@@ -2,7 +2,12 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const {clearFileState, isFileStateModified, isFileStateDeleted, setCommittedFile} = require('../state');
+const {
+  clearFileState,
+  isFileStateModified,
+  isFileStateDeleted,
+  setCommittedFile,
+} = require('../state');
 
 async function write(file) {
   const dir = path.dirname(file.path);
@@ -12,7 +17,7 @@ async function write(file) {
     }
   } catch (error) {
     if (error.code === 'ENOENT') {
-      await fs.mkdir(dir, {recursive: true});
+      await fs.mkdir(dir, { recursive: true });
     } else {
       throw error;
     }
@@ -24,11 +29,19 @@ async function write(file) {
   }
 
   await fs.writeFile(file.path, file.contents, options);
+
+  if (options.mode !== undefined) {
+    const { mode } = await fs.stat(file.path);
+    // eslint-disable-next-line no-bitwise
+    if ((mode & 0o777) !== (options.mode & 0o777)) {
+      await fs.chmod(file.path, options.mode);
+    }
+  }
 }
 
 async function remove(file) {
   const remove = fs.rm || fs.rmdir;
-  await remove(file.path, {recursive: true});
+  await remove(file.path, { recursive: true });
 }
 
 module.exports = async function (file) {

package/lib/actions/commit.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const {promisify} = require('util');
-const {pipeline: _pipeline} = require('stream');
+const { promisify } = require('util');
+const { pipeline: _pipeline } = require('stream');
 const pipeline = promisify(_pipeline);
 
-const {createPendingFilesPassthrough, createCommitTransform} = require('../transform');
+const { createPendingFilesPassthrough, createCommitTransform } = require('../transform');
 
 module.exports = function (filters, stream, cb) {
   if (typeof filters === 'function') {
@@ -23,7 +23,7 @@ module.exports = function (filters, stream, cb) {
     stream,
     createPendingFilesPassthrough(),
     ...filters,
-    createCommitTransform(this),
+    createCommitTransform(this)
   );
   if (cb) {
     return promise.then(() => cb(), cb);

package/lib/actions/copy-async.js

@@ -6,7 +6,6 @@ const fsPromises = require('fs').promises;
 const path = require('path');
 const globby = require('globby');
 const multimatch = require('multimatch');
-const ejs = require('ejs');
 const util = require('../util');
 const normalize = require('normalize-path');
 
@@ -20,7 +19,7 @@ function renderFilepath(filepath, context, tplSettings) {
     return filepath;
   }
 
-  return ejs.render(filepath, context, tplSettings);
+  return util.render(filepath, context, tplSettings);
 }
 
 async function getOneFile(from) {
@@ -36,8 +35,7 @@ async function getOneFile(from) {
     if ((await fsPromises.stat(resolved)).isFile()) {
       return resolved;
     }
-  } catch (_) {
-  }
+  } catch (_) {}
 
   return undefined;
 }
@@ -47,17 +45,27 @@ exports.copyAsync = async function (from, to, options, context, tplSettings) {
   options = options || {};
   const oneFile = await getOneFile(from);
   if (oneFile) {
-    return this._copySingleAsync(oneFile, renderFilepath(to, context, tplSettings), options);
+    return this._copySingleAsync(
+      oneFile,
+      renderFilepath(to, context, tplSettings),
+      options
+    );
   }
 
   const fromGlob = util.globify(from);
 
-  const globOptions = {...options.globOptions, nodir: true};
-  const diskFiles = globby.sync(fromGlob, globOptions).map(filepath => path.resolve(filepath));
+  const globOptions = { ...options.globOptions, nodir: true };
+  const diskFiles = globby
+    .sync(fromGlob, globOptions)
+    .map((filepath) => path.resolve(filepath));
   const storeFiles = [];
-  this.store.each(file => {
+  this.store.each((file) => {
     // The store may have a glob path and when we try to copy it will fail because not real file
-    if (!globby.hasMagic(normalize(file.path)) && multimatch([file.path], fromGlob).length !== 0 && !diskFiles.includes(file.path)) {
+    if (
+      !globby.hasMagic(normalize(file.path)) &&
+      multimatch([file.path], fromGlob).length !== 0 &&
+      !diskFiles.includes(file.path)
+    ) {
       storeFiles.push(file.path);
     }
   });
@@ -66,23 +74,40 @@ exports.copyAsync = async function (from, to, options, context, tplSettings) {
   if (Array.isArray(from) || !this.exists(from) || globby.hasMagic(normalize(from))) {
     assert(
       !this.exists(to) || fs.statSync(to).isDirectory(),
-      'When copying multiple files, provide a directory as destination',
+      'When copying multiple files, provide a directory as destination'
     );
 
-    const processDestinationPath = options.processDestinationPath || (path => path);
+    const processDestinationPath = options.processDestinationPath || ((path) => path);
     const root = util.getCommonPath(from);
-    generateDestination = filepath => {
+    generateDestination = (filepath) => {
       const toFile = path.relative(root, filepath);
       return processDestinationPath(path.join(to, toFile));
     };
   }
 
   // Sanity checks: Makes sure we copy at least one file.
-  assert(options.ignoreNoMatch || diskFiles.length > 0 || storeFiles.length > 0, 'Trying to copy from a source that does not exist: ' + from);
+  assert(
+    options.ignoreNoMatch || diskFiles.length > 0 || storeFiles.length > 0,
+    'Trying to copy from a source that does not exist: ' + from
+  );
 
   await Promise.all([
-    ...diskFiles.map(file => this._copySingleAsync(file, renderFilepath(generateDestination(file), context, tplSettings), options)),
-    ...storeFiles.map(file => Promise.resolve(this._copySingle(file, renderFilepath(generateDestination(file), context, tplSettings), options))),
+    ...diskFiles.map((file) =>
+      this._copySingleAsync(
+        file,
+        renderFilepath(generateDestination(file), context, tplSettings),
+        options
+      )
+    ),
+    ...storeFiles.map((file) =>
+      Promise.resolve(
+        this._copySingle(
+          file,
+          renderFilepath(generateDestination(file), context, tplSettings),
+          options
+        )
+      )
+    ),
   ]);
 };
 
@@ -99,7 +124,7 @@ exports._copySingleAsync = async function (from, to, options = {}) {
     }
 
     if (this.store.existsInMemory(to)) {
-      this.append(to, contents, {create: true, ...options});
+      this.append(to, contents, { create: true, ...options });
       return;
     }
   }

package/lib/actions/copy-tpl-async.js

@@ -1,8 +1,7 @@
 'use strict';
 
-const ejs = require('ejs');
 const fs = require('fs').promises;
-const {isBinary} = require('../util');
+const { isBinary, renderFile } = require('../util');
 
 module.exports = async function (from, to, context, tplSettings, options) {
   context = context || {};
@@ -12,18 +11,25 @@ module.exports = async function (from, to, context, tplSettings, options) {
     from,
     to,
     {
-      processDestinationPath: path => path.replace(/.ejs$/, ''),
+      processDestinationPath: (path) => path.replace(/.ejs$/, ''),
       ...options,
       async processFile(filename) {
         if (isBinary(filename, null)) {
           return fs.readFile(filename);
         }
 
-        return ejs.renderFile(filename, context, tplSettings);
+        return renderFile(filename, context, tplSettings);
       },
-      process: (contents, filename, destination) => this._processTpl({contents, filename, destination, context, tplSettings}),
+      process: (contents, filename, destination) =>
+        this._processTpl({
+          contents,
+          filename,
+          destination,
+          context,
+          tplSettings,
+        }),
     },
     context,
-    tplSettings,
+    tplSettings
   );
 };

package/lib/actions/copy-tpl.js

@@ -1,22 +1,18 @@
 'use strict';
 
-const ejs = require('ejs');
-const {isBinary} = require('../util');
+const { isBinary, render } = require('../util');
 
-module.exports._processTpl = function ({contents, filename, context, tplSettings}) {
+module.exports._processTpl = function ({ contents, filename, context, tplSettings }) {
   if (isBinary(filename, contents)) {
     return contents;
   }
 
-  return ejs.render(
-    contents.toString(),
-    context,
-    {
-      // Setting filename by default allow including partials.
-      filename,
-      ...tplSettings,
-    },
-  );
+  return render(contents.toString(), context, {
+    // Setting filename by default allow including partials.
+    filename,
+    cache: true,
+    ...tplSettings,
+  });
 };
 
 module.exports.copyTpl = function (from, to, context, tplSettings, options) {
@@ -27,11 +23,12 @@ module.exports.copyTpl = function (from, to, context, tplSettings, options) {
     from,
     to,
     {
-      processDestinationPath: path => path.replace(/.ejs$/, ''),
+      processDestinationPath: (path) => path.replace(/.ejs$/, ''),
       ...options,
-      process: (contents, filename) => this._processTpl({contents, filename, context, tplSettings}),
+      process: (contents, filename) =>
+        this._processTpl({ contents, filename, context, tplSettings }),
     },
     context,
-    tplSettings,
+    tplSettings
   );
 };

package/lib/actions/copy.js

@@ -5,7 +5,6 @@ const fs = require('fs');
 const path = require('path');
 const globby = require('globby');
 const multimatch = require('multimatch');
-const ejs = require('ejs');
 const util = require('../util');
 const normalize = require('normalize-path');
 
@@ -22,43 +21,54 @@ exports.copy = function (from, to, options, context, tplSettings) {
   let diskFiles = [];
   if (options.noGlob) {
     const fromFiles = Array.isArray(fromGlob) ? fromGlob : [fromGlob];
-    diskFiles = fromFiles.filter(filepath => fs.existsSync(filepath));
+    diskFiles = fromFiles.filter((filepath) => fs.existsSync(filepath));
   } else {
-    const globOptions = {...options.globOptions, nodir: true};
-    diskFiles = globby.sync(fromGlob, globOptions).map(file => path.resolve(file));
+    const globOptions = { ...options.globOptions, nodir: true };
+    diskFiles = globby.sync(fromGlob, globOptions).map((file) => path.resolve(file));
   }
 
   const storeFiles = [];
-  this.store.each(file => {
+  this.store.each((file) => {
     // The store may have a glob path and when we try to copy it will fail because not real file
-    if (!globby.hasMagic(normalize(file.path)) && multimatch([file.path], fromGlob).length !== 0 && !diskFiles.includes(file.path)) {
+    if (
+      !globby.hasMagic(normalize(file.path)) &&
+      multimatch([file.path], fromGlob).length !== 0 &&
+      !diskFiles.includes(file.path)
+    ) {
       storeFiles.push(file.path);
     }
   });
   const files = diskFiles.concat(storeFiles);
 
   let generateDestination = () => to;
-  if (Array.isArray(from) || !this.exists(from) || globby.hasMagic(normalize(from))) {
+  if (
+    Array.isArray(from) ||
+    !this.exists(from) ||
+    (globby.hasMagic(normalize(from)) && !options.noGlob)
+  ) {
     assert(
       !this.exists(to) || fs.statSync(to).isDirectory(),
-      'When copying multiple files, provide a directory as destination',
+      'When copying multiple files, provide a directory as destination'
     );
 
-    const processDestinationPath = options.processDestinationPath || (path => path);
+    const processDestinationPath = options.processDestinationPath || ((path) => path);
     const root = util.getCommonPath(from);
-    generateDestination = filepath => {
+    generateDestination = (filepath) => {
       const toFile = path.relative(root, filepath);
       return processDestinationPath(path.join(to, toFile));
     };
   }
 
   // Sanity checks: Makes sure we copy at least one file.
-  assert(options.ignoreNoMatch || files.length > 0, 'Trying to copy from a source that does not exist: ' + from);
+  assert(
+    options.ignoreNoMatch || files.length > 0,
+    'Trying to copy from a source that does not exist: ' + from
+  );
 
-  files.forEach(file => {
+  files.forEach((file) => {
     let toFile = generateDestination(file);
     if (context) {
-      toFile = ejs.render(toFile, context, tplSettings);
+      toFile = util.render(toFile, context, { ...tplSettings, cache: false });
     }
 
     this._copySingle(file, toFile, options, context, tplSettings);
@@ -70,7 +80,7 @@ exports._copySingle = function (from, to, options = {}) {
 
   const file = this.store.get(from);
 
-  let {contents} = file;
+  let { contents } = file;
   if (options.process) {
     contents = applyProcessingFunc(options.process, file.contents, file.path);
   }
@@ -81,7 +91,7 @@ exports._copySingle = function (from, to, options = {}) {
     }
 
     if (this.store.existsInMemory(to)) {
-      this.append(to, contents, {create: true, ...options});
+      this.append(to, contents, { create: true, ...options });
       return;
     }
   }

package/lib/actions/delete.js

@@ -4,7 +4,7 @@ const path = require('path');
 const globby = require('globby');
 const multimatch = require('multimatch');
 const util = require('../util');
-const {setDeletedFileState} = require('../state');
+const { setDeletedFileState } = require('../state');
 
 function deleteFile(path, store) {
   const file = store.get(path);
@@ -18,17 +18,17 @@ module.exports = function (paths, options) {
     paths = [paths];
   }
 
-  paths = paths.map(filePath => path.resolve(filePath));
+  paths = paths.map((filePath) => path.resolve(filePath));
   paths = util.globify(paths);
   options = options || {};
 
   const globOptions = options.globOptions || {};
   const files = globby.sync(paths, globOptions);
-  files.forEach(file => {
+  files.forEach((file) => {
     deleteFile(file, this.store);
   });
 
-  this.store.each(file => {
+  this.store.each((file) => {
     if (multimatch([file.path], paths).length !== 0) {
       deleteFile(file.path, this.store);
     }

package/lib/actions/dump.js

@@ -2,25 +2,37 @@
 
 const path = require('path');
 const normalize = require('normalize-path');
+const minimatch = require('minimatch');
 
-const {hasClearedState, hasState, STATE, STATE_CLEARED} = require('../state');
+const { hasClearedState, hasState, STATE, STATE_CLEARED } = require('../state');
+
+module.exports = function (
+  cwd = process.cwd(),
+  filter = (file) => hasClearedState(file) || hasState(file)
+) {
+  if (typeof filter === 'string') {
+    const pattern = filter;
+    filter = (file) => minimatch(file.path, pattern);
+  }
 
-module.exports = function (cwd = process.cwd(), filter = file => hasClearedState(file) || hasState(file)) {
   return Object.fromEntries(
-    this.store.all().filter(file => filter(file)).map(file => {
-      const filePath = normalize(cwd ? path.relative(cwd, file.path) : file.path);
-      const fileDump = {
-        contents: file.contents ? file.contents.toString() : file.contents,
-      };
-      if (file[STATE]) {
-        fileDump[STATE] = file[STATE];
-      }
+    this.store
+      .all()
+      .filter((file) => filter(file, cwd))
+      .map((file) => {
+        const filePath = normalize(cwd ? path.relative(cwd, file.path) : file.path);
+        const fileDump = {
+          contents: file.contents ? file.contents.toString() : file.contents,
+        };
+        if (file[STATE]) {
+          fileDump[STATE] = file[STATE];
+        }
 
-      if (file[STATE_CLEARED]) {
-        fileDump[STATE_CLEARED] = file[STATE_CLEARED];
-      }
+        if (file[STATE_CLEARED]) {
+          fileDump[STATE_CLEARED] = file[STATE_CLEARED];
+        }
 
-      return [filePath, fileDump];
-    }),
+        return [filePath, fileDump];
+      })
   );
 };

package/lib/actions/read-json.js

@@ -5,7 +5,9 @@ module.exports = function (filepath, defaults) {
     try {
       return JSON.parse(this.read(filepath));
     } catch (error) {
-      throw new Error('Could not parse JSON in file: ' + filepath + '. Detail: ' + error.message);
+      throw new Error(
+        'Could not parse JSON in file: ' + filepath + '. Detail: ' + error.message
+      );
     }
   } else {
     return defaults;

package/lib/actions/read.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = function (filepath, options) {
-  options = options || {raw: false};
+  options = options || { raw: false };
   const file = this.store.get(filepath);
 
   if (file.contents === null) {
@@ -9,7 +9,7 @@ module.exports = function (filepath, options) {
       return options.defaults;
     }
 
-    throw new Error(filepath + ' doesn\'t exist');
+    throw new Error(filepath + " doesn't exist");
   }
 
   return options.raw ? file.contents : file.contents.toString();

package/lib/actions/write-json.js

@@ -3,7 +3,8 @@
 const DEFAULT_INDENTATION = 2;
 
 module.exports = function (filepath, contents, replacer, space) {
-  const jsonStr = JSON.stringify(contents, replacer || null, space || DEFAULT_INDENTATION) + '\n';
+  const jsonStr =
+    JSON.stringify(contents, replacer || null, space || DEFAULT_INDENTATION) + '\n';
 
   return this.write(filepath, jsonStr);
 };

package/lib/actions/write.js

@@ -1,21 +1,21 @@
 'use strict';
 
 const assert = require('assert');
-const {isFileStateModified, setModifiedFileState} = require('../state');
+const { isFileStateModified, setModifiedFileState } = require('../state');
 
 module.exports = function (filepath, contents, stat) {
   assert(
     typeof contents === 'string' || Buffer.isBuffer(contents),
-    'Expected `contents` to be a String or a Buffer',
+    'Expected `contents` to be a String or a Buffer'
   );
 
   const file = this.store.get(filepath);
   const newContents = Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   if (
-    !isFileStateModified(file)
-    || !Buffer.isBuffer(file.contents)
-    || !newContents.equals(file.contents)
-    || (stat !== undefined && file.stat !== stat)
+    !isFileStateModified(file) ||
+    !Buffer.isBuffer(file.contents) ||
+    !newContents.equals(file.contents) ||
+    (stat !== undefined && file.stat !== stat)
   ) {
     setModifiedFileState(file);
     file.contents = newContents;

package/lib/index.js

@@ -18,7 +18,8 @@ EditionInterface.prototype._copySingle = require('./actions/copy.js')._copySingl
 EditionInterface.prototype.copyTpl = require('./actions/copy-tpl.js').copyTpl;
 EditionInterface.prototype._processTpl = require('./actions/copy-tpl.js')._processTpl;
 EditionInterface.prototype.copyAsync = require('./actions/copy-async.js').copyAsync;
-EditionInterface.prototype._copySingleAsync = require('./actions/copy-async.js')._copySingleAsync;
+EditionInterface.prototype._copySingleAsync =
+  require('./actions/copy-async.js')._copySingleAsync;
 EditionInterface.prototype.copyTplAsync = require('./actions/copy-tpl-async.js');
 EditionInterface.prototype.move = require('./actions/move.js');
 EditionInterface.prototype.commit = require('./actions/commit.js');

package/lib/state.js

@@ -14,7 +14,7 @@ const setFileState = (file, state) => {
   file[STATE] = state;
 };
 
-const isFileNew = file => {
+const isFileNew = (file) => {
   if (file[IS_NEW] === undefined) {
     file[IS_NEW] = !fs.existsSync(file.path);
   }
@@ -22,27 +22,28 @@ const isFileNew = file => {
   return file[IS_NEW];
 };
 
-const isFileStateModified = file => file[STATE] === STATE_MODIFIED;
+const isFileStateModified = (file) => file[STATE] === STATE_MODIFIED;
 
-const setModifiedFileState = file => setFileState(file, STATE_MODIFIED);
+const setModifiedFileState = (file) => setFileState(file, STATE_MODIFIED);
 
-const isFileStateDeleted = file => file[STATE] === STATE_DELETED;
+const isFileStateDeleted = (file) => file[STATE] === STATE_DELETED;
 
-const setDeletedFileState = file => setFileState(file, STATE_DELETED);
+const setDeletedFileState = (file) => setFileState(file, STATE_DELETED);
 
-const isFilePending = file => isFileStateModified(file) || (isFileStateDeleted(file) && !isFileNew(file));
+const isFilePending = (file) =>
+  isFileStateModified(file) || (isFileStateDeleted(file) && !isFileNew(file));
 
-const setCommittedFile = file => {
+const setCommittedFile = (file) => {
   file.committed = true;
 };
 
-const isFileCommitted = file => Boolean(file.committed);
+const isFileCommitted = (file) => Boolean(file.committed);
 
-const resetFileState = file => {
+const resetFileState = (file) => {
   delete file[STATE];
 };
 
-const clearFileState = file => {
+const clearFileState = (file) => {
   if (file[STATE]) {
     file[STATE_CLEARED] = file[STATE];
   }
@@ -51,9 +52,9 @@ const clearFileState = file => {
   delete file[IS_NEW];
 };
 
-const hasState = file => Boolean(file[STATE]);
+const hasState = (file) => Boolean(file[STATE]);
 
-const hasClearedState = file => Boolean(file[STATE_CLEARED]);
+const hasClearedState = (file) => Boolean(file[STATE_CLEARED]);
 
 module.exports = {
   STATE,

package/lib/transform.js

@@ -1,13 +1,18 @@
-const {createTransform} = require('./util');
-const {isFilePending} = require('./state');
+const { createTransform } = require('./util');
+const { isFilePending } = require('./state');
 
-const createPendingFilesPassthrough = () => createTransform((file, _enc, cb) => {
-  // Don't process deleted file who haven't been commited yet.
-  cb(undefined, isFilePending(file) ? file : undefined);
-});
+const createPendingFilesPassthrough = () =>
+  createTransform((file, _enc, cb) => {
+    // Don't process deleted file who haven't been commited yet.
+    cb(undefined, isFilePending(file) ? file : undefined);
+  });
 
-const createCommitTransform = memFsEditor => createTransform((file, _enc, cb) => {
-  memFsEditor.commitFileAsync(file).then(() => cb()).catch(error => cb(error));
-});
+const createCommitTransform = (memFsEditor) =>
+  createTransform((file, _enc, cb) => {
+    memFsEditor
+      .commitFileAsync(file)
+      .then(() => cb())
+      .catch((error) => cb(error));
+  });
 
-module.exports = {createPendingFilesPassthrough, createCommitTransform};
+module.exports = { createPendingFilesPassthrough, createCommitTransform };

package/lib/util.js

@@ -1,15 +1,16 @@
 'use strict';
 
+const ejs = require('ejs');
 const fs = require('fs');
 const path = require('path');
 const commondir = require('commondir');
 const globby = require('globby');
 const normalize = require('normalize-path');
-const {Transform} = require('stream');
-const {isBinaryFileSync} = require('isbinaryfile');
+const { Transform } = require('stream');
+const { isBinaryFileSync } = require('isbinaryfile');
 
-const {default: textextensions} = require('textextensions');
-const {default: binaryextensions} = require('binaryextensions');
+const { default: textextensions } = require('textextensions');
+const { default: binaryextensions } = require('binaryextensions');
 
 function notNullOrExclusion(file) {
   return file != null && file.charAt(0) !== '!';
@@ -17,9 +18,7 @@ function notNullOrExclusion(file) {
 
 exports.getCommonPath = function (filePath) {
   if (Array.isArray(filePath)) {
-    filePath = filePath
-      .filter(notNullOrExclusion)
-      .map(this.getCommonPath.bind(this));
+    filePath = filePath.filter(notNullOrExclusion).map(this.getCommonPath.bind(this));
 
     return commondir(filePath);
   }
@@ -36,7 +35,10 @@ exports.getCommonPath = function (filePath) {
 
 exports.globify = function (filePath) {
   if (Array.isArray(filePath)) {
-    return filePath.reduce((memo, pattern) => memo.concat(this.globify(normalize(pattern))), []);
+    return filePath.reduce(
+      (memo, pattern) => memo.concat(this.globify(normalize(pattern))),
+      []
+    );
   }
 
   filePath = normalize(filePath);
@@ -48,10 +50,7 @@ exports.globify = function (filePath) {
   if (!fs.existsSync(filePath)) {
     // The target of a pattern who's not a glob and doesn't match an existing
     // entity on the disk is ambiguous. As such, match both files and directories.
-    return [
-      filePath,
-      normalize(path.join(filePath, '**')),
-    ];
+    return [filePath, normalize(path.join(filePath, '**'))];
   }
 
   const fsStats = fs.statSync(filePath);
@@ -67,13 +66,12 @@ exports.globify = function (filePath) {
 };
 
 exports.createTransform = function (transform) {
-  const stream = new Transform({
+  return new Transform({
     objectMode: true,
     transform(...args) {
       return transform.apply(this, args);
     },
   });
-  return stream;
 };
 
 exports.isBinary = (filePath, newFileContents) => {
@@ -87,7 +85,18 @@ exports.isBinary = (filePath, newFileContents) => {
   }
 
   return (
-    (fs.existsSync(filePath) && isBinaryFileSync(filePath))
-    || (newFileContents && isBinaryFileSync(Buffer.isBuffer(newFileContents) ? newFileContents : Buffer.from(newFileContents)))
+    (fs.existsSync(filePath) && isBinaryFileSync(filePath)) ||
+    (newFileContents &&
+      isBinaryFileSync(
+        Buffer.isBuffer(newFileContents) ? newFileContents : Buffer.from(newFileContents)
+      ))
   );
 };
+
+exports.render = function (template, data, options) {
+  return ejs.render(template, data, { cache: false, ...options });
+};
+
+exports.renderFile = function (template, data, options) {
+  return ejs.renderFile(template, data, { cache: true, ...options });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem-fs-editor",
-  "version": "9.2.0",
+  "version": "9.5.0",
   "description": "File edition helpers working on top of mem-fs",
   "scripts": {
     "fix": "eslint . --fix",
@@ -18,9 +18,10 @@
     "binaryextensions": "^4.16.0",
     "commondir": "^1.0.1",
     "deep-extend": "^0.6.0",
-    "ejs": "^3.1.6",
-    "globby": "^11.0.3",
+    "ejs": "^3.1.8",
+    "globby": "^11.1.0",
     "isbinaryfile": "^4.0.8",
+    "minimatch": "^3.1.2",
     "multimatch": "^5.0.0",
     "normalize-path": "^3.0.0",
     "textextensions": "^5.13.0"
@@ -36,11 +37,14 @@
   "devDependencies": {
     "coveralls": "^3.0.3",
     "escape-regexp": "0.0.1",
-    "eslint": "^7.26.0",
-    "eslint-config-xo-space": "^0.29.0",
+    "eslint": "^8.5.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-xo": "^0.39.0",
+    "eslint-plugin-prettier": "^4.0.0",
     "jest": "^27.0.6",
     "mem-fs": "^2.2.1",
-    "sinon": "^11.1.2"
+    "prettier": "^2.5.1",
+    "sinon": "^12.0.1"
   },
   "jest": {
     "collectCoverage": true,