mem-fs-editor 9.0.1 → 9.3.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`.
@@ -140,3 +142,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,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,11 +1,11 @@
 'use strict';
 
-var fs = require('fs').promises;
-var path = require('path');
-var {clearFileState, isFileStateModified, isFileStateDeleted, setCommittedFile} = require('../state');
+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`);
@@ -18,18 +18,25 @@ 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) {
-  let remove = fs.rm || fs.rmdir;
+  const remove = fs.rm || fs.rmdir;
   await remove(file.path, {recursive: true});
 }
 
 module.exports = async function (file) {
-  this.store.add(file);
+  const existingFile = this.store.get(file.path);
+  if (!existingFile || existingFile !== file) {
+    this.store.add(file);
+  }
+
   if (isFileStateModified(file)) {
     setCommittedFile(file);
     await write(file);

package/lib/actions/commit.js

@@ -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

@@ -1,17 +1,17 @@
 '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');
+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) {
-  var output = await Promise.resolve(processFile.call(this, filename));
+  const output = await Promise.resolve(processFile.call(this, filename));
   return Buffer.isBuffer(output) ? output : Buffer.from(output);
 }
 
@@ -24,14 +24,14 @@ 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;
@@ -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.call(this, options.processFile, from);
+  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,7 +1,7 @@
 'use strict';
 
-var ejs = require('ejs');
-var fs = require('fs').promises;
+const ejs = require('ejs');
+const fs = require('fs').promises;
 const {isBinary} = require('../util');
 
 module.exports = async function (from, to, context, tplSettings, options) {
@@ -14,16 +14,16 @@ module.exports = async function (from, to, context, tplSettings, options) {
     {
       processDestinationPath: path => path.replace(/.ejs$/, ''),
       ...options,
-      processFile: async function (filename) {
+      async processFile(filename) {
         if (isBinary(filename, null)) {
           return fs.readFile(filename);
         }
 
         return ejs.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,6 +1,6 @@
 'use strict';
 
-var ejs = require('ejs');
+const ejs = require('ejs');
 const {isBinary} = require('../util');
 
 module.exports._processTpl = function ({contents, filename, context, tplSettings}) {
@@ -13,9 +13,9 @@ module.exports._processTpl = function ({contents, filename, context, tplSettings
     context,
     {
       // Setting filename by default allow including partials.
-      filename: filename,
-      ...tplSettings
-    }
+      filename,
+      ...tplSettings,
+    },
   );
 };
 
@@ -29,9 +29,9 @@ module.exports.copyTpl = function (from, to, context, tplSettings, options) {
     {
       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

@@ -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);
+  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,13 @@
 'use strict';
 
-var path = require('path');
-var globby = require('globby');
-var multimatch = require('multimatch');
-var util = require('../util');
-var {setDeletedFileState} = require('../state');
+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);
+  const file = store.get(path);
   setDeletedFileState(file);
   file.contents = null;
   store.add(file);
@@ -18,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

@@ -2,15 +2,21 @@
 
 const path = require('path');
 const normalize = require('normalize-path');
+const minimatch = require('minimatch');
 
 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);
+  }
+
   return Object.fromEntries(
-    this.store.all().filter(file => filter(file)).map(file => {
+    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
+        contents: file.contents ? file.contents.toString() : file.contents,
       };
       if (file[STATE]) {
         fileDump[STATE] = file[STATE];
@@ -21,6 +27,6 @@ module.exports = function (cwd = process.cwd(), filter = file => hasClearedState
       }
 
       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;
 };

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,7 +2,7 @@
 
 module.exports = function (filepath, options) {
   options = options || {raw: false};
-  var file = this.store.get(filepath);
+  const file = this.store.get(filepath);
 
   if (file.contents === null) {
     if ('defaults' in options) {

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,19 +1,27 @@
 'use strict';
 
-var assert = require('assert');
-var {setModifiedFileState} = require('../state');
+const assert = require('assert');
+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',
   );
 
-  var file = this.store.get(filepath);
-  setModifiedFileState(file);
-  file.contents = Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
-  file.stat = stat;
-  this.store.add(file);
+  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)
+  ) {
+    setModifiedFileState(file);
+    file.contents = newContents;
+    file.stat = stat;
+    this.store.add(file);
+  }
 
   return file.contents.toString();
 };

package/lib/state.js

@@ -71,5 +71,5 @@ module.exports = {
   resetFileState,
   clearFileState,
   hasState,
-  hasClearedState
+  hasClearedState,
 };

package/lib/transform.js

@@ -1,12 +1,12 @@
 const {createTransform} = require('./util');
 const {isFilePending} = require('./state');
 
-const createPendingFilesPassthrough = () => createTransform(function (file, _enc, cb) {
+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(function (file, _enc, cb) {
+const createCommitTransform = memFsEditor => createTransform((file, _enc, cb) => {
   memFsEditor.commitFileAsync(file).then(() => cb()).catch(error => cb(error));
 });
 

package/lib/util.js

@@ -1,12 +1,12 @@
 '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 isBinaryFileSync = require('isbinaryfile').isBinaryFileSync;
+const {isBinaryFileSync} = require('isbinaryfile');
 
 const {default: textextensions} = require('textextensions');
 const {default: binaryextensions} = require('binaryextensions');
@@ -24,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()) {
@@ -50,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;
   }
@@ -69,9 +69,9 @@ 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;
 };
@@ -87,7 +87,7 @@ 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)))
   );
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem-fs-editor",
-  "version": "9.0.1",
+  "version": "9.3.0",
   "description": "File edition helpers working on top of mem-fs",
   "scripts": {
     "fix": "eslint . --fix",
@@ -15,15 +15,16 @@
     "lib"
   ],
   "dependencies": {
-    "binaryextensions": "^4.15.0",
+    "binaryextensions": "^4.16.0",
     "commondir": "^1.0.1",
     "deep-extend": "^0.6.0",
     "ejs": "^3.1.6",
     "globby": "^11.0.3",
     "isbinaryfile": "^4.0.8",
+    "minimatch": "^3.0.4",
     "multimatch": "^5.0.0",
     "normalize-path": "^3.0.0",
-    "textextensions": "^5.12.0"
+    "textextensions": "^5.13.0"
   },
   "peerDependencies": {
     "mem-fs": "^2.1.0"
@@ -37,10 +38,10 @@
     "coveralls": "^3.0.3",
     "escape-regexp": "0.0.1",
     "eslint": "^7.26.0",
-    "eslint-config-xo-space": "^0.27.0",
-    "jest": "^26.6.3",
-    "mem-fs": "^2.1.0",
-    "sinon": "^10.0.0"
+    "eslint-config-xo-space": "^0.29.0",
+    "jest": "^27.0.6",
+    "mem-fs": "^2.2.1",
+    "sinon": "^11.1.2"
   },
   "jest": {
     "collectCoverage": true,