@c6fc/spellcraft 0.0.1

package/src/index.js.bak

@@ -0,0 +1,403 @@
+'use strict';
+
+const fs = require("fs");
+const os = require("os");
+const ini = require("ini");
+const path = require("path");
+const yaml = require('js-yaml');
+const crypto = require('crypto');
+const readline = require("readline");
+const { spawnSync } = require('child_process');
+const { Jsonnet } = require("@hanazuki/node-jsonnet");
+
+const baseDir = process.cwd();
+
+exports.SpellFrame = class {
+	renderPath; cliExtensions; cleanBeforeRender; fileTypeHandlers; initFn; jsonnet; lastRender; activePath; functionContext; useDefaultFileHandlers;
+
+	constructor(options) {
+
+		const defaults = {
+			renderPath: "./render",
+			cleanBeforeRender: true,
+			useDefaultFileHandlers: true
+		};
+
+		Object.keys(defaults).forEach(e => {
+			this[e] = options?.[e] ?? defaults[e];
+		});
+
+		// An array of functions aggregated from all plugins that must all succeed before files are processed
+		this.initFn = [];
+
+		// A cache of synchronous function execution results.
+		this.cache = {};
+
+		// An array of functions that extend the CLI 'yargs' argument.
+		this.cliExtensions = [];
+
+		this.fileTypeHandlers = (this.useDefaultFileHandlers) ? defaultFileTypeHandlers : {};
+		
+		// An object to pass as `this` to all functions invoked via JSonnet.
+		this.functionContext = {};
+
+		this.jsonnet = new Jsonnet()
+			.addJpath(path.join(__dirname, '../lib'))
+			.addJpath(path.join(__dirname, '../modules'));
+
+		this.addFunction("envvar", (name) => {
+			return process.env?.[name] ?? false;
+		}, "name");
+
+		this.addFunction("path", () => {
+			return `${process.cwd()}`;
+		});
+
+		this.loadModulesFromPackageList();
+
+		return this;
+	}
+
+	_cacheKey(...args) {
+		return crypto.createHash('sha256').update(JSON.stringify(args)).digest('hex');
+	}
+
+	addFileTypeHander(pattern, handler) {
+		Object.defineProperty(this.fileTypeHandlers, pattern, {
+			value: handler,
+			writable: false
+		});
+
+		return this.fileTypeHandlers;
+	}
+
+	addFunction(name, fn, ...parameters) {
+		this.jsonnet.nativeCallback(name, (...args) => {
+
+			let key = this._cacheKey(name, args);
+			if (!!this.cache?.[key]) {
+				return this.cache[key];
+			}
+
+			this.cache[key] = fn.call(this.functionContext, ...args);
+
+			return this.cache[key];
+		}, ...parameters);
+	}
+
+	export(name, value) {
+		if (typeof value !== "string") {
+			value = JSON.stringify(value);
+		}
+
+		this.jsonnet = this.jsonnet.extCode(name, value);
+		return this;
+	}
+
+	extendWithModuleMetadata(metadata) {
+		
+	}
+
+	import(path) {
+		this.jsonnet = this.jsonnet.addJpath(path);
+
+		return this;
+	}
+
+	async init() {
+		for (const step of this.initFn) {
+			await step();
+		}
+	}
+
+	async importSpellCraftModuleFromNpm(npmPackage, name = false) {
+		const npmPath = path.resolve(path.join(baseDir, 'node_modules', npmPackage));
+		if (!fs.existsSync(npmPath)) {
+			const install = spawnSync(`npm`, ['install', '-p', npmPackage], {
+				cwd: this.renderPath,
+				stdio: [process.stdin, process.stdout, process.stderr]
+			});
+		}
+
+		const configFile = path.join(npmPath, 'package.json');
+		
+		if (!fs.existsSync(configFile)) {
+			console.log(`[!] Package ${npmPackage} is missing package.json`);
+			process.exit(1);
+		}
+
+		const { config } = JSON.parse(fs.readFileSync(path.join(configFile)));
+
+		if (!name && !config?.spellcraft_module_default_name) {
+			console.log(config);
+			console.log(`[!] No import name specified, and ${npmPackage} has no default import name`);
+			process.exit(1);
+		}
+
+		const packagesDirPath = path.join(baseDir, 'spellcraft_modules');
+		if (!fs.existsSync(packagesDirPath)) {
+			fs.mkdirSync(packagesDirPath);
+		}
+
+		let packages = {};
+		const packagesFilePath = path.join(baseDir, 'spellcraft_modules', 'packages.json')
+		if (fs.existsSync(packagesFilePath)) {
+			packages = JSON.parse(fs.readFileSync(packagesFilePath));
+		}
+
+		let npmPackageBaseName;
+
+		// If the package is namespaced, 
+		if (npmPackage[0] == "@") {
+			[ , npmPackageBaseName ] = npmPackage.split('@');
+			npmPackageBaseName = `@${npmPackageBaseName}`;
+		} else {
+			[ npmPackageBaseName ] = npmPackage.split('@');
+		}
+
+		const packagesKey = name || config.spellcraft_module_default_name;
+		packages[packagesKey] = npmPackageBaseName;
+
+		fs.writeFileSync(packagesFilePath, JSON.stringify(packages, null, "\t"));
+
+		console.log(`[+] Linked ${npmPackage} as ${packagesKey}`);
+
+	}
+
+	async render(file) {
+		if (!fs.existsSync(file)) {
+			throw new Error(`Sonnetry Error: ${file} does not exist.`);
+		}
+
+		this.activePath = path.dirname(path.resolve(file));
+
+		const moduleFile = path.resolve(path.join(__dirname, '../modules/modules'));
+
+		if (fs.existsSync(moduleFile)) {
+			throw new Error(`[!] The module target file [${moduleFile}] already exists. Remove or rename it before continuing.`);
+		}
+
+		this.loadModulesFromModuleDirectory(moduleFile);
+
+		console.log(this.renderPath);
+
+		this.renderPath = (this.renderPath.split("").slice(-1)[0] == "/") ?
+			this.renderPath.split("").slice(0, -1).join("") :
+			this.renderPath;
+
+		try {
+			this.lastRender = JSON.parse(await this.jsonnet.evaluateFile(file));
+		} catch (e) {
+			throw new Error(`Error parsing Jsonnet file: ${e}`);
+		}
+
+		const modulePath = path.resolve(path.join(__dirname, '../modules/'));
+		
+		fs.readdirSync(modulePath)
+			.map(e => path.join(modulePath, e))
+			.forEach(e => fs.unlinkSync(e));
+
+		return this.lastRender;
+	}
+
+	loadModulesFromModuleDirectory(moduleFile) {
+
+		const modulePath = path.join(baseDir, 'spellcraft_modules');
+
+		if (!fs.existsSync(modulePath)) {
+			return [];
+		}
+
+		const regex = /.*?\.js$/
+		const fileList = fs.readdirSync(modulePath)
+			.filter(f => regex.test(f))
+			.map(f => path.join(modulePath, f));
+
+		return this.loadModulesFromFileList(fileList, moduleFile);
+	}
+
+	loadModulesFromPackageList() {
+		const packagePath = path.join(baseDir, 'spellcraft_modules', 'packages.json');
+
+		if (!fs.existsSync(packagePath)) {
+			console.log('No spellcraft_modules/packages.json file found. Skip package-based module import');
+			return [];
+		}
+
+		const packages = JSON.parse(fs.readFileSync(packagePath));
+
+		return Object.keys(packages).map(k => {
+			const configFile = path.join(baseDir, 'node_modules', packages[k], 'package.json');
+			const config = JSON.parse(fs.readFileSync(configFile));
+
+			const jsMainFile = path.join(baseDir, 'node_modules', packages[k], config.main);
+			this.loadFunctionsFromFile(jsMainFile);
+
+			const moduleFile = path.resolve(path.join(__dirname, '..', 'modules', k));
+			const importFile = path.resolve(path.join(jsMainFile, '..', 'module.libsonnet'));
+
+			if (fs.existsSync(importFile)) {
+				fs.copyFileSync(importFile, moduleFile);
+			}
+
+			return k;
+		});
+	}
+
+	loadModulesFromFileList(fileList, moduleFile) {
+
+		let registeredFunctions = [];
+
+		if (fileList.length < 1) {
+			return [];
+		}
+
+		let magicContent = [];
+
+		fileList.map(file => {
+			const { functions, magic } = this.loadFunctionsFromFile(file);
+			registeredFunctions = registeredFunctions.concat(functions);
+			magicContent = magicContent.concat(magic);
+		});
+
+		fs.writeFileSync(moduleFile, `{\n${magicContent.join(",\n")}\n}`);
+
+		console.log(`[+] Registered ${fileList.length} module${(fileList.length > 1) ? 's' : ''} as '${path.basename(moduleFile)}' comprising ${registeredFunctions.length} function${(registeredFunctions.length > 1) ? 's' : ''}: [ ${registeredFunctions.sort().join(', ')} ]`)
+
+		return { registeredFunctions, magicContent };
+	}
+
+	loadFunctionsFromFile(file) {
+		const functions = require(file);
+
+		const magicContent = [];
+		if (functions._spellcraft_metadata) {
+			const metadata = functions._spellcraft_metadata;
+			['fileTypeHandlers', 'functionContext'].forEach(e => Object.assign(this[e], metadata[e] ?? {}));
+
+			['cliExtensions'].forEach(e => metadata[e] && this[e].push(metadata[e]));
+
+			metadata.initFn && this.init.push(metadata.initFn);
+		}
+
+		const registeredFunctions = Object.keys(functions).filter(e => e !== '_spellcraft_metadata').map(e => {
+
+			let fn, parameters;
+
+			if (typeof functions[e] == "object") {
+				[fn, ...parameters] = functions[e];
+			}
+
+			if (typeof functions[e] == "function") {
+				fn = functions[e];
+				parameters = getFunctionParameterList(fn);
+			}
+
+			magicContent.push(`\t${e}(${parameters.join(', ')}):: std.native('${e}')(${parameters.join(', ')})`);
+
+			this.addFunction(e, fn, ...parameters);
+			return e;
+		});
+
+		return { functions: registeredFunctions, magic: magicContent };
+	}
+
+	toString() {
+		if (this?.lastRender) {
+			return this.lastRender
+		}
+
+		return null;
+	}
+
+	write(files = this.lastRender) {
+		try {
+			if (!fs.existsSync(this.renderPath)) {
+				fs.mkdirSync(this.renderPath, { recursive: true });
+			}
+		} catch (e) {
+			throw new Error(`Spellcraft Error: renderPath could not be created. ${e}`);
+		}
+
+		if (this.cleanBeforeRender) {
+			try {
+				Object.keys(this.fileTypeHandlers).forEach(regex => {
+					// console.log(regex);
+					fs.readdirSync(this.renderPath)
+						.filter(f => new RegExp(regex, "i").test(f))
+						.map(f => fs.unlinkSync(`${this.renderPath}/${f}`));
+				});
+			} catch (e) {
+				throw new Error(`Failed to remove files from renderPath. ${e}`);
+			}
+		}
+
+		try {
+			for (const filename in files) {
+				const outputPath = `${this.renderPath}/${filename}`;
+
+				const [, handler] = Object.entries(this.fileTypeHandlers)
+					.find(([pattern, ]) => new RegExp(pattern).test(filename)) || [false, defaultFileHandler];
+
+				fs.writeFileSync(outputPath, handler(files[filename]));
+				console.log('  ' + path.basename(outputPath));
+			}
+		} catch (e) {
+			throw new Error(`Failed to write to renderPath. ${e}`);
+		}
+
+		return this;
+	}
+};
+
+const defaultFileTypeHandlers = {
+	// JSON files
+	'.*?\.json$': (e) => {
+		// console.log('Using JSON encoder');
+		return JSON.stringify(e, null, 4)
+	},
+
+	// YAML files
+	'.*?\.yaml$': (e) => {
+		// console.log('Using YAML encoder');
+		yaml.dump(e, {
+			indent: 4
+		})
+	},
+
+	'.*?\.yml$': (e) => {
+		// console.log('Using YAML encoder');
+		yaml.dump(e, {
+			indent: 4
+		})
+	},
+};
+
+const defaultFileHandler = (e) => JSON.stringify(e, null, 4);
+
+function getFunctionParameterList(fn) {
+
+	let str = fn.toString();
+
+	str = str.replace(/\/\*[\s\S]*?\*\//g, '')
+		.replace(/\/\/(.)*/g, '')
+		.replace(/{[\s\S]*}/, '')
+		.replace(/=>/g, '')
+		.trim();
+
+	const start = str.indexOf("(") + 1;
+	const end = str.length - 1;
+
+	const result = str.substring(start, end).split(", ");
+
+	const params = [];
+	result.forEach(element => {
+		element = element.replace(/=[\s\S]*/g, '').trim();
+
+		if(element.length > 0) {
+			params.push(element);
+		}
+	});
+
+	return params;
+}

package/src/test.js

@@ -0,0 +1,16 @@
+#! /usr/bin/env node
+
+const fs = require('fs');
+const { SpellFrame } = require('./index.js');
+
+const sonnetry = new SpellFrame({
+	renderPath: './render',
+	cleanBeforeRender: true
+});
+
+(async () => {
+
+	testBootstrap = sonnetry.render(`local spellcraft = import 'spellcraft'; { test: spellcraft.path() }`);
+	console.log(testBootstrap);
+
+})();