5etools-utils 0.13.42 → 0.14.1

package/lib/TestData.js

@@ -4,12 +4,12 @@ import {ObjectWalker} from "./ObjectWalker.js";
 
 /** Runs multiple handlers on each file, to avoid re-reading each file for each handler */
 class _ParsedJsonChecker {
-	static _CLAZZES_FILE_HANDLER = [];
+	static _FILE_HANDLERS = [];
 
 	static _PRIMITIVE_HANDLERS = {};
 
-	static registerFileHandler (Clazz) {
-		_ParsedJsonChecker._CLAZZES_FILE_HANDLER.push(Clazz);
+	static registerFileHandler (fileHandler) {
+		this._FILE_HANDLERS.push(fileHandler);
 	}
 
 	static addPrimitiveHandler (primitiveType, handler) {
@@ -19,20 +19,22 @@ class _ParsedJsonChecker {
 
 	/* -------------------------------------------- */
 
-	static run (filePath, {fnIsIgnoredFile, fnIsIgnoredDirectory} = {}) {
-		this._fileRecurse({
+	static async pRun (filePath, {fnIsIgnoredFile, fnIsIgnoredDirectory} = {}) {
+		await this._pFileRecurse({
 			filePath,
 			fnIsIgnoredFile,
 			fnIsIgnoredDirectory,
 		});
 	}
 
-	static _fileRecurse ({filePath, fnIsIgnoredFile, fnIsIgnoredDirectory}) {
+	static async _pFileRecurse ({filePath, fnIsIgnoredFile, fnIsIgnoredDirectory}) {
 		if (fs.lstatSync(filePath).isDirectory()) {
 			if (fnIsIgnoredDirectory && fnIsIgnoredDirectory(filePath)) return;
 
-			return fs.readdirSync(filePath)
-				.forEach(nxt => this._fileRecurse({filePath: `${filePath}/${nxt}`, fnIsIgnoredFile, fnIsIgnoredDirectory}));
+			for (const nxt of fs.readdirSync(filePath)) {
+				await this._pFileRecurse({filePath: `${filePath}/${nxt}`, fnIsIgnoredFile, fnIsIgnoredDirectory});
+			}
+			return;
 		}
 
 		if (!filePath.endsWith(".json") || (fnIsIgnoredFile && fnIsIgnoredFile(filePath))) return;
@@ -45,50 +47,55 @@ class _ParsedJsonChecker {
 			primitiveHandlers: this._PRIMITIVE_HANDLERS,
 		});
 
-		this._CLAZZES_FILE_HANDLER.forEach(dataTester => dataTester.handleFile(filePath, contents));
-		this._CLAZZES_FILE_HANDLER.forEach(dataTester => dataTester.addMessageBoundary());
+		for (const dataTester of this._FILE_HANDLERS) {
+			dataTester.handleFile(filePath, contents);
+			await dataTester.pHandleFile(filePath, contents);
+			dataTester.addMessageBoundary();
+		}
 	}
 }
 
 class DataTesterBase {
-	static _MESSAGE = "";
+	_message = "";
 
-	static _addMessage (str) {
-		this._MESSAGE += str;
+	_addMessage (str) {
+		this._message += str;
 	}
 
-	static addMessageBoundary () {
-		if (!this._MESSAGE.trim()) return;
-		if (this._MESSAGE.slice(-5) === "\n---\n") return;
-		this._MESSAGE = this._MESSAGE.trimEnd();
-		this._MESSAGE += `\n---\n`;
+	addMessageBoundary () {
+		if (!this._message.trim()) return;
+		if (this._message.slice(-5) === "\n---\n") return;
+		this._message = this._message.trimEnd();
+		this._message += `\n---\n`;
 	}
 
-	static getMessage () { return this._MESSAGE; }
+	getMessage () { return this._message; }
 
 	/* -------------------------------------------- */
 
-	static async pRun () { /* Implement as required */ }
+	async pRun () { /* Implement as required */ }
 
-	static async pPostRun () { /* Implement as required */ }
+	async pPostRun () { /* Implement as required */ }
 
 	/* -------------------------------------------- */
 
-	static registerParsedFileCheckers (parsedJsonChecker) { /* Implement as required */ }
+	registerParsedFileCheckers (parsedJsonChecker) { /* Implement as required */ }
 
-	static registerParsedPrimitiveHandlers (parsedJsonChecker) { /* Implement as required */ }
+	registerParsedPrimitiveHandlers (parsedJsonChecker) { /* Implement as required */ }
 
 	/* -------------------------------------------- */
 
-	static handleFile (filePath, contents) { /* Implement as required */ }
+	handleFile (filePath, contents) { /* Implement as required */ }
+
+	async pHandleFile (filePath, contents) { /* Implement as required */ }
 }
 
 class BraceCheck extends DataTesterBase {
-	static registerParsedPrimitiveHandlers (parsedJsonChecker) {
+	registerParsedPrimitiveHandlers (parsedJsonChecker) {
 		parsedJsonChecker.addPrimitiveHandler("string", this._checkString.bind(this));
 	}
 
-	static _checkString (str, {filePath}) {
+	_checkString (str, {filePath}) {
 		let total = 0;
 		for (let i = 0; i < str.length; ++i) {
 			const c = str[i];
@@ -110,23 +117,23 @@ class BraceCheck extends DataTesterBase {
 class EscapeCharacterCheck extends DataTesterBase {
 	static _CHARS = 16;
 
-	static _errors = [];
+	_errors = [];
 
-	static registerParsedFileCheckers (parsedJsonChecker) {
+	registerParsedFileCheckers (parsedJsonChecker) {
 		parsedJsonChecker.registerFileHandler(this);
 	}
 
-	static _checkString (str) {
+	_checkString (str) {
 		let re = /([\n\t\r])/g;
 		let m;
 		while ((m = re.exec(str))) {
-			const startIx = Math.max(m.index - this._CHARS, 0);
-			const endIx = Math.min(m.index + this._CHARS, str.length);
+			const startIx = Math.max(m.index - this.constructor._CHARS, 0);
+			const endIx = Math.min(m.index + this.constructor._CHARS, str.length);
 			this._errors.push(`...${str.substring(startIx, endIx)}...`.replace(/[\n\t\r]/g, (...m) => m[0] === "\n" ? "***\\n***" : m[0] === "\t" ? "***\\t***" : "***\\r***"));
 		}
 	}
 
-	static handleFile (file, contents) {
+	handleFile (file, contents) {
 		this._errors = [];
 		ObjectWalker.walk({
 			obj: contents,
@@ -145,40 +152,40 @@ class EscapeCharacterCheck extends DataTesterBase {
 class DataTester {
 	static register (
 		{
-			ClazzDataTesters,
+			dataTesters,
 		},
 	) {
-		ClazzDataTesters.forEach(ClazzDataTester => {
-			ClazzDataTester.registerParsedPrimitiveHandlers(_ParsedJsonChecker);
-			ClazzDataTester.registerParsedFileCheckers(_ParsedJsonChecker);
+		dataTesters.forEach(dataTester => {
+			dataTester.registerParsedPrimitiveHandlers(_ParsedJsonChecker);
+			dataTester.registerParsedFileCheckers(_ParsedJsonChecker);
 		});
 	}
 
 	static async pRun (
 		filePath,
-		ClazzDataTesters,
+		dataTesters,
 		{
 			fnIsIgnoredFile,
 			fnIsIgnoredDirectory,
 		} = {},
 	) {
-		_ParsedJsonChecker.run(filePath, {fnIsIgnoredFile, fnIsIgnoredDirectory});
+		await _ParsedJsonChecker.pRun(filePath, {fnIsIgnoredFile, fnIsIgnoredDirectory});
 
-		for (const ClazzDataTester of ClazzDataTesters) {
-			await ClazzDataTester.pRun();
+		for (const dataTester of dataTesters) {
+			await dataTester.pRun();
 		}
 
-		for (const ClazzDataTester of ClazzDataTesters) {
-			await ClazzDataTester.pPostRun();
+		for (const dataTester of dataTesters) {
+			await dataTester.pPostRun();
 		}
 	}
 
-	static getLogReport (ClazzDataTesters) {
+	static getLogReport (dataTesters) {
 		let outMessage = "";
-		for (const ClazzDataTester of ClazzDataTesters) {
-			const pt = ClazzDataTester.getMessage();
-			if (pt) outMessage += `Error messages for ${ClazzDataTester.name}:\n\n${pt}\n`;
-			else console.log(`##### ${ClazzDataTester.name} passed! #####`);
+		for (const dataTester of dataTesters) {
+			const pt = dataTester.getMessage();
+			if (pt) outMessage += `Error messages for ${dataTester.constructor.name}:\n\n${pt}\n`;
+			else console.log(`##### ${dataTester.constructor.name} passed! #####`);
 		}
 
 		if (outMessage) console.error(outMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "5etools-utils",
-	"version": "0.13.42",
+	"version": "0.14.1",
 	"description": "Shared utilities for the 5etools ecosystem.",
 	"type": "module",
 	"main": "lib/Api.js",
@@ -23,6 +23,7 @@
 		"build": "node node/compile-schemas.js",
 		"test": "npm run lint:js && npm run test:js",
 		"test:js": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+		"lint": "npm run lint:js",
 		"lint:js": "eslint lib node test --fix",
 		"preversion": "npm t"
 	},