nomen-lang 0.0.5 → 0.0.7

package/src/index.ts

@@ -8,14 +8,64 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 
 import build, { default_platform } from "../../src/build.ts";
+import { format_source, type FormatOptions } from "../../src/format.ts";
 import join from "../../src/join.ts";
 import { get_library } from "../../src/lib.ts";
 import parse from "../../src/parse.ts";
-import render_errors from "./format_errors.ts";
+import { run_docs } from "./docs.ts";
+import render_errors, { render_warnings } from "./format_errors.ts";
+import { runTests } from "./test.ts";
 import type Config from "./types/Config.ts";
 
 const SUPPORTED_EXTENSION = ".nm";
 
+type Mode = "check" | "build" | "run";
+
+// Strip `//` line and `/* */` block comments so a .jsonc file parses as JSON.
+function parse_jsonc(text: string): any {
+	return JSON.parse(text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, ""));
+}
+
+/** Read the `format` options from the nearest package.jsonc above `start`. */
+function load_format_options(start: string): Partial<FormatOptions> {
+	let dir = fs.lstatSync(start).isDirectory() ? start : path.dirname(start);
+	for (let i = 0; i < 20; i++) {
+		const config_path = path.join(dir, "package.jsonc");
+		if (fs.existsSync(config_path)) {
+			try {
+				const parsed = parse_jsonc(fs.readFileSync(config_path, "utf8"));
+				if (parsed.format) return parsed.format as Partial<FormatOptions>;
+			} catch {
+				// ignore malformed package.jsonc and keep searching
+			}
+		}
+		const lib_config = path.join(dir, "core", "package.jsonc");
+		if (fs.existsSync(lib_config)) {
+			try {
+				const parsed = parse_jsonc(fs.readFileSync(lib_config, "utf8"));
+				if (parsed.format) return parsed.format as Partial<FormatOptions>;
+			} catch {
+				// ignore
+			}
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return {};
+}
+
+/** Recursively collect every `.nm` file under `folder`. */
+function collect_nm_files(folder: string): string[] {
+	const out: string[] = [];
+	for (const entry of fs.readdirSync(folder, { withFileTypes: true })) {
+		const full = path.join(folder, entry.name);
+		if (entry.isDirectory()) out.push(...collect_nm_files(full));
+		else if (shouldProcessFile(entry.name)) out.push(full);
+	}
+	return out;
+}
+
 // The folder whose `build/` subdirectory receives compiler output. Set during
 // input resolution: the --in folder, the .nm file's folder, or — for
 // package.jsonc discovery — the package folder (cwd), not the entry's folder.
@@ -23,8 +73,21 @@ let build_root: string | undefined;
 
 console.log("\n~ NOMEN ~\n");
 
-const options = yargs(hideBin(process.argv))
-	.usage("Usage: nomen --in [file/folder]")
+const parser = yargs(hideBin(process.argv))
+	.usage(
+		"Usage:\n" +
+			"  nomen run --in [file/folder]    Parse, check, build and run a program\n" +
+			"  nomen build --in [file/folder]   Parse, check and build (no run)\n" +
+			"  nomen check --in [file/folder]   Parse and check only\n" +
+			"  nomen format [--in folder]       Reformat every .nm file\n" +
+			"  nomen docs [--in file]           Generate markdown documentation",
+	)
+	.command("run", "Parse, check, build and run a program")
+	.command("build", "Parse, check and build (compile and link, but do not run)")
+	.command("check", "Parse and check only")
+	.command("format", "Reformat every .nm file")
+	.command("docs", "Generate markdown documentation")
+	.command("test", "Discover and run *.test.nm files with the Tester harness")
 	.option("in", {
 		alias: "i",
 		describe: "Input file or folder",
@@ -45,6 +108,11 @@ const options = yargs(hideBin(process.argv))
 		describe: "Whether to watch for file changes",
 		type: "boolean",
 	})
+	.option("filter", {
+		alias: "f",
+		describe: "Only run test files whose path matches this regex",
+		type: "string",
+	})
 	.option("arch", {
 		alias: "a",
 		describe: "Target architecture (aarch64 or c)",
@@ -69,10 +137,69 @@ const options = yargs(hideBin(process.argv))
 		describe: "Path to audit_runtime.c, linked in when --audit is set",
 		type: "string",
 	})
-	.help(true)
-	.parseSync();
+	.option("check", {
+		describe: "For `nomen format`: report files that would change without writing them",
+		type: "boolean",
+	})
+	.help(true);
+
+const options = parser.parseSync();
+
+const command = options._[0];
 
 try {
+	// `nomen docs` generates markdown documentation instead of compiling.
+	if (command === "docs") {
+		run_docs(typeof options.in === "string" ? options.in : undefined);
+		process.exit(0);
+	}
+
+	// `nomen test` discovers and runs every `*.test.nm` file under --in (or
+	// the cwd), compiling each into a Tester harness and reporting results.
+	if (command === "test") {
+		const root = options.in ?? process.cwd();
+		const filter = typeof options.filter === "string" ? new RegExp(options.filter) : undefined;
+		const arch = (options.arch as string | undefined) ?? "aarch64";
+		const ok = runTests(root, { arch, filter });
+		process.exit(ok ? 0 : 1);
+	}
+
+	// `nomen format` re-indents and tidies every .nm file under a folder.
+	if (command === "format") {
+		const root = options.in ?? process.cwd();
+		const format_options = load_format_options(root);
+		const files = collect_nm_files(root);
+		let changed = 0;
+		for (const file of files) {
+			const source = fs.readFileSync(file, "utf8");
+			const result = format_source(source, format_options);
+			if (result.unsafe) {
+				console.log(`Skipped ${file}: ${result.unsafe}`);
+				continue;
+			}
+			if (result.changed) {
+				if (!options.check) fs.writeFileSync(file, result.code);
+				changed += 1;
+				console.log(`Formatted ${file}`);
+			}
+		}
+		console.log(`\nFormatted ${changed} of ${files.length} file(s).`);
+		process.exit(0);
+	}
+
+	// `run`, `build` and `check` all start from parsed + checked source; `run`
+	// also links and executes, `build` stops after linking, `check` stops after
+	// checking. An unknown (or missing) command prints the help instead.
+	let mode: Mode | undefined;
+	if (command === "run") mode = "run";
+	else if (command === "build") mode = "build";
+	else if (command === "check") mode = "check";
+
+	if (!mode) {
+		parser.showHelp("log");
+		process.exit(1);
+	}
+
 	// An explicit --in wins; otherwise discover what to compile from the
 	// working folder — a package.jsonc `entry`, or a lone .nm file.
 	options.in = options.in ?? resolve_input();
@@ -100,24 +227,21 @@ try {
 
 		// Is the --in path a folder
 		if (fs.lstatSync(options.in).isDirectory()) {
-			// Loop through files in the folder
-			//processFolder(options.in);
 			if (options.watch) {
-				watchPath(options.in, config);
+				watchPath(options.in, config, mode);
 			} else {
-				processFolder(options.in, config);
+				processFolder(options.in, config, mode);
 			}
 		} else {
 			// Process the supplied file
 			const extname = path.extname(options.in);
 			if (shouldProcessFile(options.in)) {
-				//processFile(options.in);
 				// NOTE: We get add notifications for all watched files immediately
 				// TODO: Is this the case on Windows etc too?
 				if (options.watch) {
-					watchPath(options.in, config);
+					watchPath(options.in, config, mode);
 				} else {
-					processFile(options.in, config);
+					processFile(options.in, config, mode);
 				}
 			} else {
 				console.log("Unsupported file type: " + extname);
@@ -227,20 +351,20 @@ function compile_audit_runtime(config: Config, input_path: string, buildDir: str
 	return audit_obj;
 }
 
-function watchPath(p: string, config: Config) {
+function watchPath(p: string, config: Config, mode: Mode) {
 	chokidar.watch(p).on("all", (event, filePath) => {
 		if (shouldProcessFile(filePath)) {
-			processFile(filePath, config);
+			processFile(filePath, config, mode);
 		}
 	});
 }
 
-function processFolder(folder: string, config: Config) {
+function processFolder(folder: string, config: Config, mode: Mode) {
 	const dir = fs.opendirSync(folder);
 	let dirent;
 	while ((dirent = dir.readSync()) !== null) {
 		if (shouldProcessFile(dirent.name)) {
-			processFile(path.join(folder, dirent.name), config);
+			processFile(path.join(folder, dirent.name), config, mode);
 			// @ts-ignore
 			let _ = fs.watch;
 		}
@@ -252,7 +376,7 @@ function shouldProcessFile(filename: string) {
 	return path.extname(filename) === SUPPORTED_EXTENSION;
 }
 
-function processFile(filename: string, config: Config) {
+function processFile(filename: string, config: Config, mode: Mode) {
 	console.log("Processing", filename);
 
 	const arch = config.arch || "aarch64";
@@ -265,22 +389,28 @@ function processFile(filename: string, config: Config) {
 
 	let startTime = performance.now();
 
-	let input = join(path.resolve(filename), config.lib);
+	const resolved_path = path.resolve(filename);
+	const input = join(resolved_path, config.lib);
 	const library = config.lib ? get_library(config.lib) : undefined;
-	const parsed = parse(input, library);
-	// TODO: If verbose flag
-	// console.log("Parsed");
+	const parsed = parse(input, library, resolved_path);
 
 	let errors = parsed.errors;
-	const ok = !errors.length;
 
-	if (!ok) {
+	if (errors.length) {
 		console.log(render_errors(input, errors));
 		return;
 	}
 
-	// TODO: If verbose flag
-	// console.log("Built");
+	// Warnings come out of the parse/check phase, so every mode reports them.
+	if (parsed.warnings.length) console.log(render_warnings(input, parsed.warnings));
+
+	// `check` stops after parsing and checking — no building, linking or running.
+	if (mode === "check") {
+		const checkTime = performance.now();
+		console.log(`Checked in ${(checkTime - startTime).toFixed(2)}ms`);
+		return;
+	}
+
 	const result = build(parsed.root, { arch, platform, audit: config.audit });
 
 	if (result.errors && result.errors.length > 0) {
@@ -311,6 +441,7 @@ function processFile(filename: string, config: Config) {
 	console.log(`Created ${codefile} in ${(compileTime - startTime).toFixed(2)}ms`);
 	console.log("");
 
+	// `build` links the executable but does not run it; `run` links and runs.
 	startTime = performance.now();
 
 	const audit_obj = config.audit ? compile_audit_runtime(config, resolved, buildDir) : undefined;
@@ -322,6 +453,13 @@ function processFile(filename: string, config: Config) {
 			? " -framework CoreGraphics -framework Foundation -framework AppKit -lobjc"
 			: "";
 	execSync(`clang -o ${outfile} ${link_inputs}${framework_flags}`);
+
+	if (mode === "build") {
+		const buildTime = performance.now();
+		console.log(`Built ${outfile} in ${(buildTime - startTime).toFixed(2)}ms`);
+		return;
+	}
+
 	execSync(outfile, { stdio: "inherit" });
 
 	const runTime = performance.now();