5etools-utils 0.1.0 → 0.1.3

package/lib/Api.js

@@ -0,0 +1,4 @@
+
+export {
+
+};

package/lib/TestJson.js

@@ -0,0 +1,121 @@
+import * as path from "path";
+
+import Ajv from "ajv";
+import * as jsonSourceMap from "json-source-map";
+
+import * as uf from "./UtilFs.js";
+import * as um from "./UtilMisc.js";
+
+const _IS_SORT_RESULTS = !process.env.VET_TEST_JSON_RESULTS_UNSORTED;
+const _IS_TRIM_RESULTS = !process.env.VET_TEST_JSON_RESULTS_UNTRIMMED;
+
+class JsonTester {
+	static _RE_DATE = /^\d\d\d\d-\d\d-\d\d$/;
+
+	constructor (
+		{
+			dirSchema,
+			tagLog = "JSON",
+		},
+	) {
+		this._dirSchema = dirSchema;
+		this._tagLog = tagLog;
+
+		// region Set up validator
+		this._ajv = new Ajv({
+			allowUnionTypes: true,
+		});
+
+		this._ajv.addKeyword({
+			keyword: "version",
+			validate: false,
+		});
+
+		this._ajv.addFormat(
+			"date",
+			{
+				validate: str => JsonTester._RE_DATE.test(str),
+			},
+		);
+		// endregion
+	}
+
+	/**
+	 * Add any implicit data to the JSON
+	 */
+	_addImplicits (obj, lastKey) {
+		if (typeof obj !== "object") return;
+		if (obj == null) return;
+		if (obj instanceof Array) obj.forEach(it => this._addImplicits(it, lastKey));
+		else {
+			// "obj.mode" will be set if this is in a "_copy" etc. block
+			if (lastKey === "spellcasting" && !obj.mode) obj.type = obj.type || "spellcasting";
+
+			Object.entries(obj).forEach(([k, v]) => this._addImplicits(v, k));
+		}
+	}
+
+	_getFileErrors ({filePath}) { return `${filePath}\n${JSON.stringify(ajv.errors, null, 2)}`; }
+
+	_handleError ({filePath, errors, errorsFull, data}) {
+		if (!process.env.CI) errorsFull.push(this._getFileErrors({filePath}));
+
+		// Sort the deepest errors to the bottom, as these are the ones we're most likely to be the ones we care about
+		//   manually checking.
+		if (_IS_SORT_RESULTS) {
+			this._ajv.errors.sort((a, b) => (a.instancePath.length ?? -1) - (b.instancePath.length ?? -1));
+		}
+
+		// If there are an excessive number of errors, it's probably a junk entry; show only the first error and let the
+		//   user figure it out.
+		if (_IS_TRIM_RESULTS && this._ajv.errors.length > 5) {
+			console.error(`(${this._ajv.errors.length} errors found, showing (hopefully) most-relevant one)`);
+			this._ajv.errors = this._ajv.errors.slice(-1);
+		}
+
+		// Add line numbers
+		const sourceMap = jsonSourceMap.stringify(data, null, "\t");
+		this._ajv.errors.forEach(it => {
+			const errorPointer = sourceMap.pointers[it.instancePath];
+			it.lineNumberStart = errorPointer.value.line;
+			it.lineNumberEnd = errorPointer.valueEnd.line;
+		});
+
+		const error = this._getFileErrors({filePath});
+		um.error(this._tagLog, error);
+		errors.push(error);
+	}
+
+	getErrors () {
+		um.info(this._tagLog, `Validating JSON against schema`);
+
+		uf.listJsonFiles(this._dirSchema)
+			.forEach(filePath => {
+				filePath = path.normalize(filePath);
+				const contents = uf.readJSON(filePath);
+
+				const relativeFilePath = path.relative(this._dirSchema, filePath)
+					.replace(/\\/g, "/");
+
+				this._ajv.addSchema(contents, relativeFilePath);
+			});
+
+		const errors = [];
+		const errorsFull = [];
+
+		uf.runOnDirs((dir) => {
+			uf.listJsonFiles(dir)
+				.forEach(filePath => {
+					const data = uf.readJSON(filePath);
+					this._addImplicits(data);
+					const valid = this._ajv.validate("homebrew.json", data);
+
+					if (!valid) this._handleError({filePath, errors, errorsFull, data});
+				});
+		});
+
+		return {errors, errorsFull};
+	}
+}
+
+export {JsonTester};

package/lib/UtilFs.js

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+
+function isDirectory (path) {
+	return fs.lstatSync(path).isDirectory();
+}
+
+function readJSON (path) {
+	try {
+		if (fs.existsSync(path)) {
+			let str = fs.readFileSync(path, "utf8");
+			// Strip BOM(s)
+			while (str.charCodeAt(0) === 0xFEFF) str = str.slice(1);
+			return JSON.parse(str);
+		} else {
+			const parts = path.split(/[\\/]+/g);
+			const dir = parts.slice(0, -1).join("/");
+			const originalName = parts[parts.length - 1];
+			const filenames = fs.readdirSync(dir, "utf8");
+			const filename = filenames.find(it => it.toLowerCase() === originalName.toLowerCase());
+			if (filename) return JSON.parse(fs.readFileSync(`${dir}/${filename}`, "utf8"));
+			else throw new Error(`Could not find file "${path}"`);
+		}
+	} catch (e) {
+		e.message += ` (Path: ${path})`;
+		throw e;
+	}
+}
+
+function listJsonFiles (dir) {
+	const dirContent = fs.readdirSync(dir, "utf8")
+		.map(file => `${dir}/${file}`);
+	return dirContent.reduce((acc, file) => {
+		if (isDirectory(file)) acc.push(...listJsonFiles(file));
+		else {
+			if (file.toLowerCase().endsWith(".json")) acc.push(file);
+		}
+		return acc;
+	}, []);
+}
+
+function runOnDirs (fn) {
+	fs.readdirSync(".", "utf8")
+		.filter(dir => isDirectory(dir) && !dir.startsWith(".") && !dir.startsWith("_") && dir !== "node_modules")
+		.forEach(dir => fn(dir));
+}
+
+function mkDirs (pathToCreate) {
+	pathToCreate
+		.split(/[\\/]/g)
+		.reduce((currentPath, folder) => {
+			currentPath += `${folder}/`;
+			if (!fs.existsSync(currentPath)) {
+				fs.mkdirSync(currentPath);
+			}
+			return currentPath;
+		}, "");
+}
+
+export {
+	readJSON,
+	listJsonFiles,
+	runOnDirs,
+	mkDirs,
+};

package/lib/UtilMisc.js

@@ -0,0 +1,22 @@
+function _taggedConsole (fn, tag, ...args) {
+	const expandedTag = tag.padStart(12, " ");
+	fn(`[${expandedTag}]`, ...args);
+}
+
+function warn (tag, ...args) {
+	_taggedConsole(console.warn, tag, ...args);
+}
+
+function info (tag, ...args) {
+	_taggedConsole(console.info, tag, ...args);
+}
+
+function error (tag, ...args) {
+	_taggedConsole(console.error, tag, ...args);
+}
+
+export {
+	warn,
+	info,
+	error,
+};

package/package.json

@@ -1,10 +1,19 @@
 {
 	"name": "5etools-utils",
-	"version": "0.1.0",
+	"version": "0.1.3",
 	"description": "Shared utilities for the 5etools ecosystem.",
 	"type": "module",
+	"main": "lib/Api.js",
+	"files": [
+		"lib"
+	],
+	"directories": {
+		"lib": "./lib"
+	},
 	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
+		"test": "npm run test:js",
+		"test:js": "eslint lib",
+		"lint:js": "eslint lib --fix"
 	},
 	"repository": {
 		"type": "git",

package/.editorconfig

@@ -1,7 +0,0 @@
-[*]
-charset=utf-8
-end_of_line=lf
-trim_trailing_whitespace=true
-insert_final_newline=true
-indent_style=tab
-indent_size=3

package/.eslintrc.js

@@ -1,184 +0,0 @@
-module.exports = {
-	"extends": "eslint:recommended",
-	"env": {
-		"browser": true,
-		"es6": true,
-		"jquery": true
-	},
-	"parserOptions": {
-		"ecmaVersion": "latest",
-		"sourceType": "module"
-	},
-	"rules": {
-		"accessor-pairs": "off",
-		"arrow-spacing": ["error", {"before": true, "after": true}],
-		"block-spacing": ["error", "always"],
-		"brace-style": ["error", "1tbs", {"allowSingleLine": true}],
-		"comma-dangle": ["error", {
-			"arrays": "always-multiline",
-			"objects": "always-multiline",
-			"imports": "always-multiline",
-			"exports": "always-multiline",
-			"functions": "always-multiline"
-		}],
-		"comma-spacing": ["error", {"before": false, "after": true}],
-		"comma-style": ["error", "last"],
-		"constructor-super": "error",
-		"curly": ["error", "multi-line"],
-		"dot-location": ["error", "property"],
-		"eqeqeq": ["error", "always", {"null": "ignore"}],
-		"func-call-spacing": ["error", "never"],
-		"generator-star-spacing": ["error", {"before": false, "after": true}],
-		"handle-callback-err": ["error", "^(err|error)$"],
-		"indent": [
-			"error",
-			"tab",
-			{
-				"SwitchCase": 1
-			}
-		],
-		"key-spacing": ["error", {"beforeColon": false, "afterColon": true}],
-		"keyword-spacing": ["error", {"before": true, "after": true}],
-		"new-cap": ["error", {"newIsCap": true, "capIsNew": false}],
-		"new-parens": "error",
-		"no-array-constructor": "error",
-		"no-caller": "error",
-		"no-class-assign": "error",
-		"no-compare-neg-zero": "error",
-		"no-cond-assign": "error",
-		"no-const-assign": "error",
-		"no-constant-condition": ["error", {"checkLoops": false}],
-		"no-control-regex": "error",
-		"no-debugger": "error",
-		"no-delete-var": "error",
-		"no-dupe-args": "error",
-		"no-dupe-class-members": "error",
-		"no-dupe-keys": "error",
-		"no-duplicate-case": "error",
-		"no-empty-character-class": "error",
-		"no-empty-pattern": "error",
-		"no-eval": "error",
-		"no-ex-assign": "error",
-		"no-extra-bind": "error",
-		"no-extra-boolean-cast": "error",
-		"no-extra-parens": ["error", "functions"],
-		"no-fallthrough": "error",
-		"no-floating-decimal": "error",
-		"no-func-assign": "error",
-		"no-global-assign": "error",
-		"no-implied-eval": "error",
-		"no-inner-declarations": ["error", "functions"],
-		"no-invalid-regexp": "error",
-		"no-irregular-whitespace": "error",
-		"no-iterator": "error",
-		"no-label-var": "error",
-		"no-labels": ["error", {"allowLoop": true, "allowSwitch": false}],
-		"no-lone-blocks": "error",
-		"no-mixed-operators": ["error", {
-			"groups": [
-				["==", "!=", "===", "!==", ">", ">=", "<", "<="],
-				["&&", "||"],
-				["in", "instanceof"]
-			],
-			"allowSamePrecedence": true
-		}],
-		"no-mixed-spaces-and-tabs": "error",
-		"no-multi-spaces": "error",
-		"no-multi-str": "error",
-		"no-multiple-empty-lines": ["error", {"max": 1, "maxEOF": 0}],
-		"no-negated-in-lhs": "error",
-		"no-new": "error",
-		"no-new-func": "error",
-		"no-new-object": "error",
-		"no-new-require": "error",
-		"no-new-symbol": "error",
-		"no-new-wrappers": "error",
-		"no-obj-calls": "error",
-		"no-octal": "error",
-		"no-octal-escape": "error",
-		"no-path-concat": "error",
-		"no-proto": "error",
-		"no-redeclare": "error",
-		"no-regex-spaces": "error",
-		"no-return-await": "error",
-		"no-self-assign": "error",
-		"no-self-compare": "error",
-		"no-sequences": "error",
-		"no-shadow-restricted-names": "error",
-		"no-sparse-arrays": "error",
-		"no-template-curly-in-string": "error",
-		"no-this-before-super": "error",
-		"no-throw-literal": "error",
-		"no-trailing-spaces": "error",
-		"no-undef": "off",
-		"no-undef-init": "error",
-		"no-unexpected-multiline": "error",
-		"no-unmodified-loop-condition": "error",
-		"no-unneeded-ternary": ["error", {"defaultAssignment": false}],
-		"no-unreachable": "error",
-		"no-unsafe-finally": "error",
-		"no-unsafe-negation": "error",
-		"no-unused-expressions": ["error", {
-			"allowShortCircuit": true,
-			"allowTernary": true,
-			"allowTaggedTemplates": true
-		}],
-		"no-unused-vars": "off",
-		"no-use-before-define": ["error", {"functions": false, "classes": false, "variables": false}],
-		"no-useless-call": "error",
-		"no-useless-computed-key": "error",
-		"no-useless-constructor": "error",
-		"no-useless-escape": "error",
-		"no-useless-rename": "error",
-		"no-useless-return": "error",
-		"no-whitespace-before-property": "error",
-		"no-with": "error",
-		"object-property-newline": ["error", {"allowMultiplePropertiesPerLine": true}],
-		"one-var": ["error", {"initialized": "never"}],
-		"operator-linebreak": ["error", "after", {
-			"overrides": {
-				"?": "before",
-				":": "before",
-				"+": "before",
-				"-": "before",
-				"*": "before",
-				"/": "before",
-				"||": "before",
-				"&&": "before"
-			}
-		}],
-		"padded-blocks": ["error", {"blocks": "never", "switches": "never", "classes": "never"}],
-		"prefer-promise-reject-errors": "error",
-		"rest-spread-spacing": ["error", "never"],
-		"semi": ["warn", "always"],
-		"semi-spacing": ["error", {"before": false, "after": true}],
-		"space-before-blocks": ["error", "always"],
-		"space-before-function-paren": ["error", "always"],
-		"space-in-parens": ["error", "never"],
-		"space-infix-ops": "error",
-		"space-unary-ops": ["error", {"words": true, "nonwords": false}],
-		"spaced-comment": ["error", "always", {
-			"line": {"markers": ["*package", "!", "/", ",", "="]},
-			"block": {
-				"balanced": true,
-				"markers": ["*package", "!", ",", ":", "::", "flow-include"],
-				"exceptions": ["*"]
-			}
-		}],
-		"symbol-description": "error",
-		"template-curly-spacing": ["error", "never"],
-		"template-tag-spacing": ["error", "never"],
-		"unicode-bom": ["error", "never"],
-		"use-isnan": "error",
-		"valid-typeof": ["error", {"requireStringLiterals": true}],
-		"wrap-iife": ["error", "any", {"functionPrototypeMethods": true}],
-		"yield-star-spacing": ["error", "both"],
-		"yoda": ["error", "never"],
-		"no-prototype-builtins": "off",
-		"require-atomic-updates": "off",
-		"no-console": "error",
-		"prefer-template": "error",
-		"quotes": ["error", "double", {"allowTemplateLiterals": true}],
-		"no-var": "error"
-	}
-};

package/HelloWorld.js

@@ -1,3 +0,0 @@
-export const helloWorld = () => {
-	console.log("Hello world!");
-};