file-entry-cache 8.0.0 → 9.1.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)
@@ -18,14 +17,16 @@ npm i --save file-entry-cache
 
 The module exposes two functions `create` and `createFromFile`.
 
-## `create(cacheName, [directory, useCheckSum])`
+## `create(cacheName, [directory, useCheckSum, currentWorkingDir])`
 - **cacheName**: the name of the cache to be created
 - **directory**: Optional the directory to load the cache from
 - **usecheckSum**: Whether to use md5 checksum to verify if file changed. If false the default will be to use the mtime and size of the file.
+- **currentWorkingDir**: Optional the current working directory to use when resolving relative paths
 
-## `createFromFile(pathToCache, [useCheckSum])`
+## `createFromFile(pathToCache, [useCheckSum, currentWorkingDir])`
 - **pathToCache**: the path to the cache file (this combines the cache name and directory)
 - **useCheckSum**: Whether to use md5 checksum to verify if file changed. If false the default will be to use the mtime and size of the file.
+- **currentWorkingDir**: Optional the current working directory to use when resolving relative paths
 
 ```js
 // loads the cache, if one does not exists for the given
@@ -110,6 +111,6 @@ In the worst case scenario all the files will be processed. In the best case sce
 
 ## License
 
-MIT
+MIT (c) Jared Wray
 
 

package/cache.js

@@ -1,64 +1,76 @@
-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 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, currentWorkingDir) {
+		const fname = path.basename(filePath);
+		const dir = path.dirname(filePath);
+		return this.create(fname, dir, useChecksum, currentWorkingDir);
+	},
+
+	create(cacheId, _path, useChecksum, currentWorkingDir) {
+		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 {
+					let filePath = fPath;
+					if (currentWorkingDir) {
+						filePath = path.join(currentWorkingDir, fPath);
+					}
+
+					fs.statSync(filePath);
+				} 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,
 
-      /**
+			/**
+       * To enable relative paths as the key with current working directory
+       * @type {string}
+       */
+			currentWorkingDir: currentWorkingDir ?? undefined,
+
+			/**
        * 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 +78,114 @@ 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 {
+					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);
+			},
+
+			_getFileKey(file) {
+				if (this.currentWorkingDir) {
+					return file.split(this.currentWorkingDir).pop();
+				}
+
+				return file;
+			},
+
+			_getFileDescriptorUsingMtimeAndSize(file, fstat) {
+				let meta = cache.getKey(this._getFileKey(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[this._getFileKey(file)] = {
+					key: this._getFileKey(file),
+					changed: !cacheExists || isDifferentDate || isDifferentSize,
+					meta,
+				});
+
+				return nEntry;
+			},
+
+			_getFileDescriptorUsingChecksum(file) {
+				let meta = cache.getKey(this._getFileKey(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[this._getFileKey(file)] = {
+					key: this._getFileKey(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 +193,126 @@ 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) {
+				delete normalizedEntries[this._getFileKey(entryName)];
+				cache.removeKey(this._getFileKey(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) {
+				let filePath = cacheEntry.key;
+				if (this.currentWorkingDir) {
+					filePath = path.join(this.currentWorkingDir, filePath);
+				}
+
+				const contentBuffer = fs.readFileSync(filePath);
+				const hash = this.getHash(contentBuffer);
+				const meta = Object.assign(cacheEntry.meta, {hash});
+				delete meta.size;
+				delete meta.mtime;
+				return meta;
+			},
+
+			_getMetaForFileUsingMtimeAndSize(cacheEntry) {
+				let filePath = cacheEntry.key;
+				if (currentWorkingDir) {
+					filePath = path.join(currentWorkingDir, filePath);
+				}
+
+				const stat = fs.statSync(filePath);
+				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(this._getFileKey(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": "8.0.0",
+  "version": "9.1.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,21 +13,20 @@
     "cache.js"
   ],
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18"
   },
   "scripts": {
-    "eslint": "eslint --cache --cache-location=node_modules/.cache/ 'cache.js' 'test/**/*.js' 'perf.js'",
-    "autofix": "npm run eslint -- --fix",
-    "clean": "rimraf ./node_modules ./package-lock.json ./yarn.lock",
-    "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/cache.js test/relative.js",
+    "test:relative": "rimraf ./rfixtures ./tfixtures && mocha test/relative.js",
+    "test:ci": "xo && c8 --reporter=lcov mocha -R spec test/specs/cache.js test/relative.js",
     "perf": "node perf.js"
   },
   "prepush": [
-    "npm run eslint --silent"
+    "npm run test"
   ],
   "precommit": [
-    "npm run eslint --silent"
+    "npm run test"
   ],
   "keywords": [
     "file cache",
@@ -38,19 +37,23 @@
     "cache"
   ],
   "devDependencies": {
-    "c8": "^8.0.1",
+    "c8": "^10.1.2",
     "chai": "^4.3.10",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-mocha": "^10.2.0",
-    "eslint-plugin-prettier": "^5.0.1",
     "glob-expand": "^0.2.1",
-    "mocha": "^10.2.0",
-    "prettier": "^3.1.1",
-    "rimraf": "^5.0.5",
-    "write": "^2.0.0"
+    "mocha": "^10.5.1",
+    "rimraf": "^5.0.7",
+    "webpack": "^5.92.1",
+    "write": "^2.0.0",
+    "xo": "^0.58.0"
   },
   "dependencies": {
-    "flat-cache": "^4.0.0"
+    "flat-cache": "^5.0.0"
+  },
+  "xo": {
+    "rules": {
+      "unicorn/prefer-module": "off",
+      "n/prefer-global/process": "off",
+      "unicorn/prevent-abbreviations": "off"
+    }
   }
 }