file-entry-cache 7.0.2 → 9.0.0

package/README.md

@@ -1,6 +1,5 @@
 # file-entry-cache
-> Super simple cache for file metadata, useful for process that work on a given series of files
-> and that only need to repeat the job on the changed ones since the previous run of the process — Edit
+> Super simple cache for file metadata, useful for process that work on a given series of files and that only need to repeat the job on the changed ones since the previous run of the process
 
 [![NPM Version](https://img.shields.io/npm/v/file-entry-cache.svg?style=flat)](https://npmjs.org/package/file-entry-cache)
 [![tests](https://github.com/jaredwray/file-entry-cache/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/jaredwray/file-entry-cache/actions/workflows/tests.yaml)

package/cache.js

@@ -1,64 +1,66 @@
-var path = require('path');
-var crypto = require('crypto');
+/* eslint-disable unicorn/no-this-assignment, func-names, no-multi-assign  */
+const path = require('node:path');
+const process = require('node:process');
+const crypto = require('node:crypto');
 
 module.exports = {
-  createFromFile: function (filePath, useChecksum) {
-    var fname = path.basename(filePath);
-    var dir = path.dirname(filePath);
-    return this.create(fname, dir, useChecksum);
-  },
-
-  create: function (cacheId, _path, useChecksum) {
-    var fs = require('fs');
-    var flatCache = require('flat-cache');
-    var cache = flatCache.load(cacheId, _path);
-    var normalizedEntries = {};
-
-    var removeNotFoundFiles = function removeNotFoundFiles() {
-      const cachedEntries = cache.keys();
-      // remove not found entries
-      cachedEntries.forEach(function remover(fPath) {
-        try {
-          fs.statSync(fPath);
-        } catch (err) {
-          if (err.code === 'ENOENT') {
-            cache.removeKey(fPath);
-          }
-        }
-      });
-    };
-
-    removeNotFoundFiles();
-
-    return {
-      /**
-       * the flat cache storage used to persist the metadata of the `files
+	createFromFile(filePath, useChecksum) {
+		const fname = path.basename(filePath);
+		const dir = path.dirname(filePath);
+		return this.create(fname, dir, useChecksum);
+	},
+
+	create(cacheId, _path, useChecksum) {
+		const fs = require('node:fs');
+		const flatCache = require('flat-cache');
+		const cache = flatCache.load(cacheId, _path);
+		let normalizedEntries = {};
+
+		const removeNotFoundFiles = function removeNotFoundFiles() {
+			const cachedEntries = cache.keys();
+			// Remove not found entries
+			for (const fPath of cachedEntries) {
+				try {
+					fs.statSync(fPath);
+				} catch (error) {
+					if (error.code === 'ENOENT') {
+						cache.removeKey(fPath);
+					}
+				}
+			}
+		};
+
+		removeNotFoundFiles();
+
+		return {
+			/**
+       * The flat cache storage used to persist the metadata of the `files
        * @type {Object}
        */
-      cache: cache,
+			cache,
 
-      /**
+			/**
        * Given a buffer, calculate md5 hash of its content.
        * @method getHash
        * @param  {Buffer} buffer   buffer to calculate hash on
        * @return {String}          content hash digest
        */
-      getHash: function (buffer) {
-        return crypto.createHash('md5').update(buffer).digest('hex');
-      },
+			getHash(buffer) {
+				return crypto.createHash('md5').update(buffer).digest('hex');
+			},
 
-      /**
+			/**
        * Return whether or not a file has changed since last time reconcile was called.
        * @method hasFileChanged
        * @param  {String}  file  the filepath to check
        * @return {Boolean}       wheter or not the file has changed
        */
-      hasFileChanged: function (file) {
-        return this.getFileDescriptor(file).changed;
-      },
+			hasFileChanged(file) {
+				return this.getFileDescriptor(file).changed;
+			},
 
-      /**
-       * given an array of file paths it return and object with three arrays:
+			/**
+       * Given an array of file paths it return and object with three arrays:
        *  - changedFiles: Files that changed since previous run
        *  - notChangedFiles: Files that haven't change
        *  - notFoundFiles: Files that were not found, probably deleted
@@ -66,103 +68,110 @@ module.exports = {
        * @param  {Array} files the files to analyze and compare to the previous seen files
        * @return {[type]}       [description]
        */
-      analyzeFiles: function (files) {
-        var me = this;
-        files = files || [];
-
-        var res = {
-          changedFiles: [],
-          notFoundFiles: [],
-          notChangedFiles: [],
-        };
-
-        me.normalizeEntries(files).forEach(function (entry) {
-          if (entry.changed) {
-            res.changedFiles.push(entry.key);
-            return;
-          }
-          if (entry.notFound) {
-            res.notFoundFiles.push(entry.key);
-            return;
-          }
-          res.notChangedFiles.push(entry.key);
-        });
-        return res;
-      },
-
-      getFileDescriptor: function (file) {
-        var fstat;
-
-        try {
-          fstat = fs.statSync(file);
-        } catch (ex) {
-          this.removeEntry(file);
-          return { key: file, notFound: true, err: ex };
-        }
-
-        if (useChecksum) {
-          return this._getFileDescriptorUsingChecksum(file);
-        }
-
-        return this._getFileDescriptorUsingMtimeAndSize(file, fstat);
-      },
-
-      _getFileDescriptorUsingMtimeAndSize: function (file, fstat) {
-        var meta = cache.getKey(file);
-        var cacheExists = !!meta;
-
-        var cSize = fstat.size;
-        var cTime = fstat.mtime.getTime();
-
-        var isDifferentDate;
-        var isDifferentSize;
-
-        if (!meta) {
-          meta = { size: cSize, mtime: cTime };
-        } else {
-          isDifferentDate = cTime !== meta.mtime;
-          isDifferentSize = cSize !== meta.size;
-        }
-
-        var nEntry = (normalizedEntries[file] = {
-          key: file,
-          changed: !cacheExists || isDifferentDate || isDifferentSize,
-          meta: meta,
-        });
-
-        return nEntry;
-      },
-
-      _getFileDescriptorUsingChecksum: function (file) {
-        var meta = cache.getKey(file);
-        var cacheExists = !!meta;
-
-        var contentBuffer;
-        try {
-          contentBuffer = fs.readFileSync(file);
-        } catch (ex) {
-          contentBuffer = '';
-        }
-
-        var isDifferent = true;
-        var hash = this.getHash(contentBuffer);
-
-        if (!meta) {
-          meta = { hash: hash };
-        } else {
-          isDifferent = hash !== meta.hash;
-        }
-
-        var nEntry = (normalizedEntries[file] = {
-          key: file,
-          changed: !cacheExists || isDifferent,
-          meta: meta,
-        });
-
-        return nEntry;
-      },
-
-      /**
+			analyzeFiles(files) {
+				const me = this;
+				files ||= [];
+
+				const res = {
+					changedFiles: [],
+					notFoundFiles: [],
+					notChangedFiles: [],
+				};
+
+				for (const entry of me.normalizeEntries(files)) {
+					if (entry.changed) {
+						res.changedFiles.push(entry.key);
+						continue;
+					}
+
+					if (entry.notFound) {
+						res.notFoundFiles.push(entry.key);
+						continue;
+					}
+
+					res.notChangedFiles.push(entry.key);
+				}
+
+				return res;
+			},
+
+			getFileDescriptor(file) {
+				let fstat;
+
+				try {
+					if (!path.isAbsolute(file)) {
+						file = path.resolve(process.cwd(), file);
+					}
+
+					fstat = fs.statSync(file);
+				} catch (error) {
+					this.removeEntry(file);
+					return {key: file, notFound: true, err: error};
+				}
+
+				if (useChecksum) {
+					return this._getFileDescriptorUsingChecksum(file);
+				}
+
+				return this._getFileDescriptorUsingMtimeAndSize(file, fstat);
+			},
+
+			_getFileDescriptorUsingMtimeAndSize(file, fstat) {
+				let meta = cache.getKey(file);
+				const cacheExists = Boolean(meta);
+
+				const cSize = fstat.size;
+				const cTime = fstat.mtime.getTime();
+
+				let isDifferentDate;
+				let isDifferentSize;
+
+				if (meta) {
+					isDifferentDate = cTime !== meta.mtime;
+					isDifferentSize = cSize !== meta.size;
+				} else {
+					meta = {size: cSize, mtime: cTime};
+				}
+
+				const nEntry = (normalizedEntries[file] = {
+					key: file,
+					changed: !cacheExists || isDifferentDate || isDifferentSize,
+					meta,
+				});
+
+				return nEntry;
+			},
+
+			_getFileDescriptorUsingChecksum(file) {
+				let meta = cache.getKey(file);
+				const cacheExists = Boolean(meta);
+
+				let contentBuffer;
+				try {
+					contentBuffer = fs.readFileSync(file);
+				} catch {
+					contentBuffer = '';
+				}
+
+				let isDifferent = true;
+				const hash = this.getHash(contentBuffer);
+
+				if (meta) {
+					isDifferent = hash !== meta.hash;
+				} else {
+					meta = {hash};
+				}
+
+				const nEntry = (normalizedEntries[file] = {
+					key: file,
+					changed: !cacheExists || isDifferent,
+					meta,
+				});
+
+				return nEntry;
+			},
+
+			/**
        * Return the list o the files that changed compared
        * against the ones stored in the cache
        *
@@ -170,122 +179,120 @@ module.exports = {
        * @param files {Array} the array of files to compare against the ones in the cache
        * @returns {Array}
        */
-      getUpdatedFiles: function (files) {
-        var me = this;
-        files = files || [];
-
-        return me
-          .normalizeEntries(files)
-          .filter(function (entry) {
-            return entry.changed;
-          })
-          .map(function (entry) {
-            return entry.key;
-          });
-      },
-
-      /**
-       * return the list of files
+			getUpdatedFiles(files) {
+				const me = this;
+				files ||= [];
+
+				return me
+					.normalizeEntries(files)
+					.filter(entry => entry.changed)
+					.map(entry => entry.key);
+			},
+
+			/**
+       * Return the list of files
        * @method normalizeEntries
        * @param files
        * @returns {*}
        */
-      normalizeEntries: function (files) {
-        files = files || [];
+			normalizeEntries(files) {
+				files ||= [];
 
-        var me = this;
-        var nEntries = files.map(function (file) {
-          return me.getFileDescriptor(file);
-        });
+				const me = this;
+				const nEntries = files.map(file => me.getFileDescriptor(file));
 
-        //normalizeEntries = nEntries;
-        return nEntries;
-      },
+				// NormalizeEntries = nEntries;
+				return nEntries;
+			},
 
-      /**
+			/**
        * Remove an entry from the file-entry-cache. Useful to force the file to still be considered
        * modified the next time the process is run
        *
        * @method removeEntry
        * @param entryName
        */
-      removeEntry: function (entryName) {
-        delete normalizedEntries[entryName];
-        cache.removeKey(entryName);
-      },
+			removeEntry(entryName) {
+				if (!path.isAbsolute(entryName)) {
+					entryName = path.resolve(process.cwd(), entryName);
+				}
 
-      /**
+				delete normalizedEntries[entryName];
+				cache.removeKey(entryName);
+			},
+
+			/**
        * Delete the cache file from the disk
        * @method deleteCacheFile
        */
-      deleteCacheFile: function () {
-        cache.removeCacheFile();
-      },
+			deleteCacheFile() {
+				cache.removeCacheFile();
+			},
 
-      /**
-       * remove the cache from the file and clear the memory cache
+			/**
+       * Remove the cache from the file and clear the memory cache
        */
-      destroy: function () {
-        normalizedEntries = {};
-        cache.destroy();
-      },
-
-      _getMetaForFileUsingCheckSum: function (cacheEntry) {
-        var contentBuffer = fs.readFileSync(cacheEntry.key);
-        var hash = this.getHash(contentBuffer);
-        var meta = Object.assign(cacheEntry.meta, { hash: hash });
-        delete meta.size;
-        delete meta.mtime;
-        return meta;
-      },
-
-      _getMetaForFileUsingMtimeAndSize: function (cacheEntry) {
-        var stat = fs.statSync(cacheEntry.key);
-        var meta = Object.assign(cacheEntry.meta, {
-          size: stat.size,
-          mtime: stat.mtime.getTime(),
-        });
-        delete meta.hash;
-        return meta;
-      },
-
-      /**
+			destroy() {
+				normalizedEntries = {};
+				cache.destroy();
+			},
+
+			_getMetaForFileUsingCheckSum(cacheEntry) {
+				const contentBuffer = fs.readFileSync(cacheEntry.key);
+				const hash = this.getHash(contentBuffer);
+				const meta = Object.assign(cacheEntry.meta, {hash});
+				delete meta.size;
+				delete meta.mtime;
+				return meta;
+			},
+
+			_getMetaForFileUsingMtimeAndSize(cacheEntry) {
+				const stat = fs.statSync(cacheEntry.key);
+				const meta = Object.assign(cacheEntry.meta, {
+					size: stat.size,
+					mtime: stat.mtime.getTime(),
+				});
+				delete meta.hash;
+				return meta;
+			},
+
+			/**
        * Sync the files and persist them to the cache
        * @method reconcile
        */
-      reconcile: function (noPrune) {
-        removeNotFoundFiles();
-
-        noPrune = typeof noPrune === 'undefined' ? true : noPrune;
-
-        var entries = normalizedEntries;
-        var keys = Object.keys(entries);
-
-        if (keys.length === 0) {
-          return;
-        }
-
-        var me = this;
-
-        keys.forEach(function (entryName) {
-          var cacheEntry = entries[entryName];
-
-          try {
-            var meta = useChecksum
-              ? me._getMetaForFileUsingCheckSum(cacheEntry)
-              : me._getMetaForFileUsingMtimeAndSize(cacheEntry);
-            cache.setKey(entryName, meta);
-          } catch (err) {
-            // if the file does not exists we don't save it
-            // other errors are just thrown
-            if (err.code !== 'ENOENT') {
-              throw err;
-            }
-          }
-        });
-
-        cache.save(noPrune);
-      },
-    };
-  },
+			reconcile(noPrune) {
+				removeNotFoundFiles();
+
+				noPrune = noPrune === undefined ? true : noPrune;
+
+				const entries = normalizedEntries;
+				const keys = Object.keys(entries);
+
+				if (keys.length === 0) {
+					return;
+				}
+
+				const me = this;
+
+				for (const entryName of keys) {
+					const cacheEntry = entries[entryName];
+
+					try {
+						const meta = useChecksum
+							? me._getMetaForFileUsingCheckSum(cacheEntry)
+							: me._getMetaForFileUsingMtimeAndSize(cacheEntry);
+						cache.setKey(entryName, meta);
+					} catch (error) {
+						// If the file does not exists we don't save it
+						// other errors are just thrown
+						if (error.code !== 'ENOENT') {
+							throw error;
+						}
+					}
+				}
+
+				cache.save(noPrune);
+			},
+		};
+	},
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "file-entry-cache",
-  "version": "7.0.2",
+  "version": "9.0.0",
   "description": "Super simple cache for file metadata, useful for process that work o a given series of files and that only need to repeat the job on the changed ones since the previous run of the process",
   "repository": "jaredwray/file-entry-cache",
   "license": "MIT",
@@ -13,20 +13,19 @@
     "cache.js"
   ],
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=18"
   },
   "scripts": {
-    "eslint": "eslint --cache --cache-location=node_modules/.cache/ 'cache.js' 'test/**/*.js' 'perf.js'",
-    "autofix": "npm run eslint -- --fix",
-    "test": "npm run eslint --silent && c8 mocha -R spec test/specs",
-    "test:ci": "npm run eslint --silent && c8 --reporter=lcov mocha -R spec test/specs",
+    "clean": "rimraf ./coverage /node_modules ./package-lock.json ./yarn.lock ./pnpm-lock.yaml",
+    "test": "xo --fix && c8 mocha -R spec test/specs",
+    "test:ci": "xo && c8 --reporter=lcov mocha -R spec test/specs",
     "perf": "node perf.js"
   },
   "prepush": [
-    "npm run eslint --silent"
+    "npm run test"
   ],
   "precommit": [
-    "npm run eslint --silent"
+    "npm run test"
   ],
   "keywords": [
     "file cache",
@@ -37,18 +36,23 @@
     "cache"
   ],
   "devDependencies": {
-    "c8": "^8.0.1",
+    "c8": "^9.1.0",
     "chai": "^4.3.10",
-    "eslint": "^8.50.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-mocha": "^10.2.0",
-    "eslint-plugin-prettier": "^3.1.4",
     "glob-expand": "^0.2.1",
-    "mocha": "^10.2.0",
-    "prettier": "^2.1.2",
-    "write": "^2.0.0"
+    "mocha": "^10.4.0",
+    "rimraf": "^5.0.7",
+    "webpack": "^5.91.0",
+    "write": "^2.0.0",
+    "xo": "^0.58.0"
   },
   "dependencies": {
-    "flat-cache": "^3.2.0"
+    "flat-cache": "^5.0.0"
+  },
+  "xo": {
+    "rules": {
+      "unicorn/prefer-module": "off",
+      "n/prefer-global/process": "off",
+      "unicorn/prevent-abbreviations": "off"
+    }
   }
 }