mem-fs-editor 8.1.2 → 9.1.0

package/README.md

@@ -82,6 +82,8 @@ Optionally, pass an `options.process` function (`process(contents)`) returning a
 
 Optionally, when `from` is a glob pattern, pass an `options.processDestinationPath` function (`processDestinationPath(destinationFile)`) returning a string who'll become the new file name.
 
+`options.noGlob` can be used to by bypass glob matching entirely. In that case, `from` will directly match file paths against the file system.
+
 ### `#copyAsync(from, to, [options], context[, templateOptions ])`
 
 Async version of `copy`.

package/lib/actions/append-tpl.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var ejs = require('ejs');
+const ejs = require('ejs');
 
 module.exports = function (to, contents, context, tplSettings, options) {
   context = context || {};
@@ -11,7 +11,7 @@ module.exports = function (to, contents, context, tplSettings, options) {
     ejs.render(
       contents.toString(),
       context,
-      tplSettings
+      tplSettings,
     ),
     options);
 };

package/lib/actions/append.js

@@ -1,12 +1,12 @@
 'use strict';
 
-var EOL = require('os').EOL;
+const {EOL} = require('os');
 
 module.exports = function (to, contents, options) {
   options = {
     trimEnd: true,
     separator: EOL,
-    ...options
+    ...options,
   };
 
   if (!this.exists(to) && options.create) {
@@ -14,7 +14,7 @@ module.exports = function (to, contents, options) {
     return;
   }
 
-  var currentContents = this.read(to);
+  let currentContents = this.read(to);
   if (options.trimEnd) {
     currentContents = currentContents.replace(/\s+$/, '');
   }

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

@@ -1,10 +1,11 @@
 'use strict';
 
-var fs = require('fs').promises;
-var path = require('path');
+const fs = require('fs').promises;
+const path = require('path');
+const {clearFileState, isFileStateModified, isFileStateDeleted, setCommittedFile} = require('../state');
 
 async function write(file) {
-  var dir = path.dirname(file.path);
+  const dir = path.dirname(file.path);
   try {
     if (!(await fs.stat(dir)).isDirectory()) {
       throw new Error(`${file.path} is not a directory`);
@@ -17,25 +18,28 @@ async function write(file) {
     }
   }
 
-  await fs.writeFile(file.path, file.contents, {
-    mode: file.stat ? file.stat.mode : null
-  });
+  const options = {};
+  if (file.stat) {
+    options.mode = file.stat.mode;
+  }
+
+  await fs.writeFile(file.path, file.contents, options);
 }
 
 async function remove(file) {
-  await fs.rmdir(file.path, {recursive: true});
+  const remove = fs.rm || fs.rmdir;
+  await remove(file.path, {recursive: true});
 }
 
 module.exports = async function (file) {
   this.store.add(file);
-  if (file.state === 'modified') {
-    file.committed = true;
+  if (isFileStateModified(file)) {
+    setCommittedFile(file);
     await write(file);
-  } else if (file.state === 'deleted') {
-    file.committed = true;
+  } else if (isFileStateDeleted(file)) {
+    setCommittedFile(file);
     await remove(file);
   }
 
-  delete file.state;
-  delete file.isNew;
+  clearFileState(file);
 };

package/lib/actions/commit.js

@@ -1,11 +1,12 @@
 'use strict';
 
-var {pipeline} = require('stream');
-const {createTransform} = require('../util');
+const {promisify} = require('util');
+const {pipeline: _pipeline} = require('stream');
+const pipeline = promisify(_pipeline);
 
-module.exports = function (filters, stream, cb) {
-  var self = this;
+const {createPendingFilesPassthrough, createCommitTransform} = require('../transform');
 
+module.exports = function (filters, stream, cb) {
   if (typeof filters === 'function') {
     cb = filters;
     filters = [];
@@ -16,24 +17,17 @@ module.exports = function (filters, stream, cb) {
   }
 
   stream = stream || this.store.stream();
-  var modifiedFilter = createTransform(function (file, _enc, cb) {
-    // Don't process deleted file who haven't been commited yet.
-    if (file.state === 'modified' || (file.state === 'deleted' && !file.isNew)) {
-      this.push(file);
-    }
-
-    cb();
-  });
+  filters = filters || [];
 
-  var commitFilter = createTransform(function (file, _enc, cb) {
-    self.commitFileAsync(file).then(() => cb()).catch(error => cb(error));
-  });
-
-  pipeline(
+  const promise = pipeline(
     stream,
-    modifiedFilter,
+    createPendingFilesPassthrough(),
     ...filters,
-    commitFilter,
-    (...args) => cb(...args)
+    createCommitTransform(this),
   );
+  if (cb) {
+    return promise.then(() => cb(), cb);
+  }
+
+  return promise;
 };

package/lib/actions/copy-async.js

@@ -1,18 +1,18 @@
 'use strict';
 
-var assert = require('assert');
-var fs = require('fs');
-var fsPromises = require('fs').promises;
-var path = require('path');
-var globby = require('globby');
-var multimatch = require('multimatch');
-var ejs = require('ejs');
-var util = require('../util');
-var normalize = require('normalize-path');
-
-async function applyProcessingFileFunc(processFile, filename, self) {
-  var output = await Promise.resolve(processFile.call(self, filename));
-  return output instanceof Buffer ? output : Buffer.from(output);
+const assert = require('assert');
+const fs = require('fs');
+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');
+
+async function applyProcessingFileFunc(processFile, filename) {
+  const output = await Promise.resolve(processFile.call(this, filename));
+  return Buffer.isBuffer(output) ? output : Buffer.from(output);
 }
 
 function renderFilepath(filepath, context, tplSettings) {
@@ -24,19 +24,19 @@ function renderFilepath(filepath, context, tplSettings) {
 }
 
 async function getOneFile(from) {
-  var oneFile;
+  let oneFile;
   if (typeof from === 'string') {
     oneFile = from;
   } else {
     return undefined;
   }
 
-  var resolved = path.resolve(oneFile);
+  const resolved = path.resolve(oneFile);
   try {
     if ((await fsPromises.stat(resolved)).isFile()) {
       return resolved;
     }
-  } catch (e) {
+  } catch (_) {
   }
 
   return undefined;
@@ -45,16 +45,16 @@ async function getOneFile(from) {
 exports.copyAsync = async function (from, to, options, context, tplSettings) {
   to = path.resolve(to);
   options = options || {};
-  var oneFile = await getOneFile(from);
+  const oneFile = await getOneFile(from);
   if (oneFile) {
     return this._copySingleAsync(oneFile, renderFilepath(to, context, tplSettings), options);
   }
 
-  var fromGlob = util.globify(from);
+  const fromGlob = util.globify(from);
 
-  var globOptions = {...options.globOptions, nodir: true};
-  var diskFiles = globby.sync(fromGlob, globOptions).map(filepath => path.resolve(filepath));
-  var storeFiles = [];
+  const globOptions = {...options.globOptions, nodir: true};
+  const diskFiles = globby.sync(fromGlob, globOptions).map(filepath => path.resolve(filepath));
+  const storeFiles = [];
   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)) {
@@ -62,17 +62,17 @@ exports.copyAsync = async function (from, to, options, context, tplSettings) {
     }
   });
 
-  var generateDestination = () => to;
+  let generateDestination = () => to;
   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);
-    var root = util.getCommonPath(from);
+    const root = util.getCommonPath(from);
     generateDestination = filepath => {
-      var toFile = path.relative(root, filepath);
+      const toFile = path.relative(root, filepath);
       return processDestinationPath(path.join(to, toFile));
     };
   }
@@ -81,12 +81,8 @@ exports.copyAsync = async function (from, to, options, context, tplSettings) {
   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 => {
-      return this._copySingleAsync(file, renderFilepath(generateDestination(file), context, tplSettings), options);
-    }),
-    ...storeFiles.map(file => {
-      return 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))),
   ]);
 };
 
@@ -95,7 +91,7 @@ exports._copySingleAsync = async function (from, to, options = {}) {
     return this._copySingle(from, to, options);
   }
 
-  var contents = await applyProcessingFileFunc(options.processFile, from, this);
+  const contents = await applyProcessingFileFunc.call(this, options.processFile, from);
 
   if (options.append) {
     if (!this.store.existsInMemory) {
@@ -108,6 +104,6 @@ exports._copySingleAsync = async function (from, to, options = {}) {
     }
   }
 
-  var stat = await fsPromises.stat(from);
+  const stat = await fsPromises.stat(from);
   this.write(to, contents, stat);
 };

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

@@ -1,21 +1,8 @@
 'use strict';
 
-var ejs = require('ejs');
-var fs = require('fs').promises;
-var {isBinaryFile} = require('isbinaryfile');
-const {render} = require('../util');
-
-async function renderFile(filename, context, tplSettings) {
-  let result;
-
-  if (await isBinaryFile(filename)) {
-    result = await fs.readFile(filename);
-  } else {
-    result = await ejs.renderFile(filename, context, tplSettings);
-  }
-
-  return result;
-}
+const ejs = require('ejs');
+const fs = require('fs').promises;
+const {isBinary} = require('../util');
 
 module.exports = async function (from, to, context, tplSettings, options) {
   context = context || {};
@@ -27,18 +14,16 @@ module.exports = async function (from, to, context, tplSettings, options) {
     {
       processDestinationPath: path => path.replace(/.ejs$/, ''),
       ...options,
-      processFile: async function (filename) {
-        return renderFile(filename, context, tplSettings);
+      async processFile(filename) {
+        if (isBinary(filename, null)) {
+          return fs.readFile(filename);
+        }
+
+        return ejs.renderFile(filename, context, tplSettings);
       },
-      process: function (contents, filename) {
-        return render(contents, context, {
-          // Setting filename by default allow including partials.
-          filename: filename,
-          ...tplSettings
-        });
-      }
+      process: (contents, filename, destination) => this._processTpl({contents, filename, destination, context, tplSettings}),
     },
     context,
-    tplSettings
+    tplSettings,
   );
 };

package/lib/actions/copy-tpl.js

@@ -1,8 +1,25 @@
 'use strict';
 
-const {render} = require('../util');
+const ejs = require('ejs');
+const {isBinary} = require('../util');
 
-module.exports = function (from, to, context, tplSettings, options) {
+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,
+    },
+  );
+};
+
+module.exports.copyTpl = function (from, to, context, tplSettings, options) {
   context = context || {};
   tplSettings = tplSettings || {};
 
@@ -12,15 +29,9 @@ module.exports = function (from, to, context, tplSettings, options) {
     {
       processDestinationPath: path => path.replace(/.ejs$/, ''),
       ...options,
-      process: function (contents, filename) {
-        return render(contents, context, {
-          // Setting filename by default allow including partials.
-          filename: filename,
-          ...tplSettings
-        });
-      }
+      process: (contents, filename) => this._processTpl({contents, filename, context, tplSettings}),
     },
     context,
-    tplSettings
+    tplSettings,
   );
 };

package/lib/actions/copy.js

@@ -1,46 +1,53 @@
 'use strict';
 
-var assert = require('assert');
-var fs = require('fs');
-var path = require('path');
-var globby = require('globby');
-var multimatch = require('multimatch');
-var ejs = require('ejs');
-var util = require('../util');
-var normalize = require('normalize-path');
+const assert = require('assert');
+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');
 
 function applyProcessingFunc(process, contents, filename) {
-  var output = process(contents, filename);
-  return output instanceof Buffer ? output : Buffer.from(output);
+  const output = process(contents, filename);
+  return Buffer.isBuffer(output) ? output : Buffer.from(output);
 }
 
 exports.copy = function (from, to, options, context, tplSettings) {
   to = path.resolve(to);
   options = options || {};
-  var fromGlob = util.globify(from);
+  const fromGlob = util.globify(from);
 
-  var globOptions = {...options.globOptions, nodir: true};
-  var diskFiles = globby.sync(fromGlob, globOptions).map(file => path.resolve(file));
-  var storeFiles = [];
+  let diskFiles = [];
+  if (options.noGlob) {
+    const fromFiles = Array.isArray(fromGlob) ? fromGlob : [fromGlob];
+    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 storeFiles = [];
   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)) {
       storeFiles.push(file.path);
     }
   });
-  var files = diskFiles.concat(storeFiles);
+  const files = diskFiles.concat(storeFiles);
 
-  var generateDestination = () => to;
+  let generateDestination = () => to;
   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);
-    var root = util.getCommonPath(from);
+    const root = util.getCommonPath(from);
     generateDestination = filepath => {
-      var toFile = path.relative(root, filepath);
+      const toFile = path.relative(root, filepath);
       return processDestinationPath(path.join(to, toFile));
     };
   }
@@ -49,7 +56,7 @@ exports.copy = function (from, to, options, context, tplSettings) {
   assert(options.ignoreNoMatch || files.length > 0, 'Trying to copy from a source that does not exist: ' + from);
 
   files.forEach(file => {
-    var toFile = generateDestination(file);
+    let toFile = generateDestination(file);
     if (context) {
       toFile = ejs.render(toFile, context, tplSettings);
     }
@@ -61,9 +68,9 @@ exports.copy = function (from, to, options, context, tplSettings) {
 exports._copySingle = function (from, to, options = {}) {
   assert(this.exists(from), 'Trying to copy from a source that does not exist: ' + from);
 
-  var file = this.store.get(from);
+  const file = this.store.get(from);
 
-  var contents = file.contents;
+  let {contents} = file;
   if (options.process) {
     contents = applyProcessingFunc(options.process, file.contents, file.path);
   }

package/lib/actions/delete.js

@@ -1,13 +1,14 @@
 'use strict';
 
-var path = require('path');
-var globby = require('globby');
-var multimatch = require('multimatch');
-var util = require('../util');
+const path = require('path');
+const globby = require('globby');
+const multimatch = require('multimatch');
+const util = require('../util');
+const {setDeletedFileState} = require('../state');
 
 function deleteFile(path, store) {
-  var file = store.get(path);
-  file.state = 'deleted';
+  const file = store.get(path);
+  setDeletedFileState(file);
   file.contents = null;
   store.add(file);
 }
@@ -17,21 +18,19 @@ module.exports = function (paths, options) {
     paths = [paths];
   }
 
-  paths = paths.map(function (filePath) {
-    return path.resolve(filePath);
-  });
+  paths = paths.map(filePath => path.resolve(filePath));
   paths = util.globify(paths);
   options = options || {};
 
-  var globOptions = options.globOptions || {};
-  var files = globby.sync(paths, globOptions);
-  files.forEach(function (file) {
+  const globOptions = options.globOptions || {};
+  const files = globby.sync(paths, globOptions);
+  files.forEach(file => {
     deleteFile(file, this.store);
-  }.bind(this));
+  });
 
-  this.store.each(function (file) {
+  this.store.each(file => {
     if (multimatch([file.path], paths).length !== 0) {
       deleteFile(file.path, this.store);
     }
-  }.bind(this));
+  });
 };

package/lib/actions/dump.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const path = require('path');
+const normalize = require('normalize-path');
+
+const {hasClearedState, hasState, STATE, STATE_CLEARED} = require('../state');
+
+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];
+      }
+
+      if (file[STATE_CLEARED]) {
+        fileDump[STATE_CLEARED] = file[STATE_CLEARED];
+      }
+
+      return [filePath, fileDump];
+    }),
+  );
+};

package/lib/actions/exists.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = function (filepath) {
-  var file = this.store.get(filepath);
+  const file = this.store.get(filepath);
 
-  return file.contents !== null && file.state !== 'deleted';
+  return file.contents !== null;
 };

package/lib/actions/extend-json.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var extend = require('deep-extend');
+const extend = require('deep-extend');
 
 module.exports = function (filepath, contents, replacer, space) {
-  var originalContent = this.readJSON(filepath, {});
-  var newContent = extend({}, originalContent, contents);
+  const originalContent = this.readJSON(filepath, {});
+  const newContent = extend({}, originalContent, contents);
 
   this.writeJSON(filepath, newContent, replacer, space);
 };

package/lib/actions/read.js

@@ -2,9 +2,9 @@
 
 module.exports = function (filepath, options) {
   options = options || {raw: false};
-  var file = this.store.get(filepath);
+  const file = this.store.get(filepath);
 
-  if (file.state === 'deleted' || file.contents === null) {
+  if (file.contents === null) {
     if ('defaults' in options) {
       return options.defaults;
     }

package/lib/actions/write-json.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var DEFAULT_INDENTATION = 2;
+const DEFAULT_INDENTATION = 2;
 
 module.exports = function (filepath, contents, replacer, space) {
-  var 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,17 +1,17 @@
 'use strict';
 
-var assert = require('assert');
+const assert = require('assert');
+const {setModifiedFileState} = require('../state');
 
 module.exports = function (filepath, contents, stat) {
   assert(
-    typeof contents === 'string' || contents instanceof Buffer,
-    'Expected `contents` to be a String or a Buffer'
+    typeof contents === 'string' || Buffer.isBuffer(contents),
+    'Expected `contents` to be a String or a Buffer',
   );
 
-  var file = this.store.get(filepath);
-  file.isNew = file.contents === null;
-  file.state = 'modified';
-  file.contents = typeof contents === 'string' ? Buffer.from(contents) : contents;
+  const file = this.store.get(filepath);
+  setModifiedFileState(file);
+  file.contents = Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
   file.stat = stat;
   this.store.add(file);
 

package/lib/index.js

@@ -15,14 +15,18 @@ EditionInterface.prototype.appendTpl = require('./actions/append-tpl.js');
 EditionInterface.prototype.delete = require('./actions/delete.js');
 EditionInterface.prototype.copy = require('./actions/copy.js').copy;
 EditionInterface.prototype._copySingle = require('./actions/copy.js')._copySingle;
-EditionInterface.prototype.copyTpl = require('./actions/copy-tpl.js');
+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.copyTplAsync = require('./actions/copy-tpl-async.js');
 EditionInterface.prototype.move = require('./actions/move.js');
 EditionInterface.prototype.commit = require('./actions/commit.js');
 EditionInterface.prototype.commitFileAsync = require('./actions/commit-file-async.js');
+EditionInterface.prototype.dump = require('./actions/dump.js');
 
 exports.create = function (store) {
   return new EditionInterface(store);
 };
+
+exports.State = require('./state');

package/lib/state.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+
+const STATE = 'state';
+
+const STATE_CLEARED = 'stateCleared';
+
+const STATE_MODIFIED = 'modified';
+
+const STATE_DELETED = 'deleted';
+
+const IS_NEW = 'isNew';
+
+const setFileState = (file, state) => {
+  file[STATE] = state;
+};
+
+const isFileNew = file => {
+  if (file[IS_NEW] === undefined) {
+    file[IS_NEW] = !fs.existsSync(file.path);
+  }
+
+  return file[IS_NEW];
+};
+
+const isFileStateModified = file => file[STATE] === STATE_MODIFIED;
+
+const setModifiedFileState = file => setFileState(file, STATE_MODIFIED);
+
+const isFileStateDeleted = file => file[STATE] === STATE_DELETED;
+
+const setDeletedFileState = file => setFileState(file, STATE_DELETED);
+
+const isFilePending = file => isFileStateModified(file) || (isFileStateDeleted(file) && !isFileNew(file));
+
+const setCommittedFile = file => {
+  file.committed = true;
+};
+
+const isFileCommitted = file => Boolean(file.committed);
+
+const resetFileState = file => {
+  delete file[STATE];
+};
+
+const clearFileState = file => {
+  if (file[STATE]) {
+    file[STATE_CLEARED] = file[STATE];
+  }
+
+  resetFileState(file);
+  delete file[IS_NEW];
+};
+
+const hasState = file => Boolean(file[STATE]);
+
+const hasClearedState = file => Boolean(file[STATE_CLEARED]);
+
+module.exports = {
+  STATE,
+  STATE_CLEARED,
+  STATE_MODIFIED,
+  STATE_DELETED,
+  isFileStateModified,
+  setModifiedFileState,
+  isFileStateDeleted,
+  setDeletedFileState,
+  setCommittedFile,
+  isFileCommitted,
+  isFileNew,
+  isFilePending,
+  resetFileState,
+  clearFileState,
+  hasState,
+  hasClearedState,
+};

package/lib/transform.js

@@ -0,0 +1,13 @@
+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 createCommitTransform = memFsEditor => createTransform((file, _enc, cb) => {
+  memFsEditor.commitFileAsync(file).then(() => cb()).catch(error => cb(error));
+});
+
+module.exports = {createPendingFilesPassthrough, createCommitTransform};

package/lib/util.js

@@ -1,13 +1,15 @@
 'use strict';
 
-var fs = require('fs');
-var path = require('path');
-var commondir = require('commondir');
-var globby = require('globby');
-var normalize = require('normalize-path');
+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');
-var ejs = require('ejs');
-var isBinaryFileSync = require('isbinaryfile').isBinaryFileSync;
+const {isBinaryFileSync} = require('isbinaryfile');
+
+const {default: textextensions} = require('textextensions');
+const {default: binaryextensions} = require('binaryextensions');
 
 function notNullOrExclusion(file) {
   return file != null && file.charAt(0) !== '!';
@@ -22,7 +24,7 @@ exports.getCommonPath = function (filePath) {
     return commondir(filePath);
   }
 
-  var globStartIndex = filePath.indexOf('*');
+  const globStartIndex = filePath.indexOf('*');
   if (globStartIndex !== -1) {
     filePath = filePath.substring(0, globStartIndex + 1);
   } else if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
@@ -48,11 +50,11 @@ exports.globify = function (filePath) {
     // entity on the disk is ambiguous. As such, match both files and directories.
     return [
       filePath,
-      normalize(path.join(filePath, '**'))
+      normalize(path.join(filePath, '**')),
     ];
   }
 
-  var fsStats = fs.statSync(filePath);
+  const fsStats = fs.statSync(filePath);
   if (fsStats.isFile()) {
     return filePath;
   }
@@ -67,27 +69,25 @@ exports.globify = function (filePath) {
 exports.createTransform = function (transform) {
   const stream = new Transform({
     objectMode: true,
-    transform: function (...args) {
+    transform(...args) {
       return transform.apply(this, args);
-    }
+    },
   });
   return stream;
 };
 
-exports.render = function (contents, context, tplSettings) {
-  let result;
-
-  const contentsBuffer = Buffer.from(contents, 'binary');
-  if (isBinaryFileSync(contentsBuffer, contentsBuffer.length)) {
-    result = contentsBuffer;
-  } else {
-    result = ejs.render(
-      contents.toString(),
-      context,
-      tplSettings
-    );
+exports.isBinary = (filePath, newFileContents) => {
+  const extension = path.extname(filePath).replace(/^\./, '') || path.basename(filePath);
+  if (binaryextensions.includes(extension)) {
+    return true;
   }
 
-  return result;
-};
+  if (textextensions.includes(extension)) {
+    return false;
+  }
 
+  return (
+    (fs.existsSync(filePath) && isBinaryFileSync(filePath))
+    || (newFileContents && isBinaryFileSync(Buffer.isBuffer(newFileContents) ? newFileContents : Buffer.from(newFileContents)))
+  );
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem-fs-editor",
-  "version": "8.1.2",
+  "version": "9.1.0",
   "description": "File edition helpers working on top of mem-fs",
   "scripts": {
     "fix": "eslint . --fix",
@@ -15,16 +15,18 @@
     "lib"
   ],
   "dependencies": {
+    "binaryextensions": "^4.15.0",
     "commondir": "^1.0.1",
     "deep-extend": "^0.6.0",
     "ejs": "^3.1.6",
-    "globby": "^11.0.2",
-    "isbinaryfile": "^4.0.0",
+    "globby": "^11.0.3",
+    "isbinaryfile": "^4.0.8",
     "multimatch": "^5.0.0",
-    "normalize-path": "^3.0.0"
+    "normalize-path": "^3.0.0",
+    "textextensions": "^5.12.0"
   },
   "peerDependencies": {
-    "mem-fs": "^1.2.0 || ^2.0.0"
+    "mem-fs": "^2.1.0"
   },
   "peerDependenciesMeta": {
     "mem-fs": {
@@ -34,11 +36,11 @@
   "devDependencies": {
     "coveralls": "^3.0.3",
     "escape-regexp": "0.0.1",
-    "eslint": "^6.0.0",
-    "eslint-config-xo-space": "^0.21.0",
-    "jest": "^24.8.0",
-    "mem-fs": "2.0.0",
-    "sinon": "^8.0.0"
+    "eslint": "^7.26.0",
+    "eslint-config-xo-space": "^0.28.0",
+    "jest": "^27.0.6",
+    "mem-fs": "^2.2.1",
+    "sinon": "^11.1.2"
   },
   "jest": {
     "collectCoverage": true,