recipe-tmlanguage 0.3.2 → 0.3.3

package/bin/recipe-tmlang.mjs

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { cwd, exit } from "node:process";
+import { fileURLToPath } from "node:url";
+import { cli, command, flag } from "dreamcli";
+import { COUNTERS, NUMBER_WORDS, PERIODS, PERIOD_PLURALS } from "tree-sitter-recipe/grammar/dutch";
+import { COMPOUNDING, COMPOUNDING_MULTIWORD, CONDITIONAL, CONDITIONAL_MULTIWORD, DISPENSING, DISPENSING_MULTIWORD, FORMS, FORMS_MULTIWORD, FREQUENCY, ROUTE, ROUTE_MULTIWORD, TIMING, TIMING_MULTIWORD, WARNING } from "tree-sitter-recipe/grammar/latin";
+import { UNITS } from "tree-sitter-recipe/grammar/units";
+//#region src/grammar.ts
+/**
+* @file Pure grammar builder — imports the tree-sitter-recipe vocabulary and
+* compiles it into a TextMate grammar object. No filesystem I/O; the CLI
+* handles serialization and writes.
+*
+* Scopes are standard TextMate names with a `.recipe` suffix so themes paint
+* recipe blocks without a custom theme shipment.
+*/
+const SCOPE = {
+	rxMarker: "keyword.control.directive.rx.recipe",
+	dispenseMarker: "keyword.control.directive.dispense.recipe",
+	signaMarker: "keyword.control.directive.signa.recipe",
+	frequency: "keyword.other.frequency.recipe",
+	timing: "keyword.other.timing.recipe",
+	route: "support.function.route.recipe",
+	dispensing: "entity.other.attribute-name.recipe",
+	warning: "invalid.illegal.warning.recipe",
+	form: "storage.type.form.recipe",
+	compounding: "keyword.operator.compounding.recipe",
+	conditional: "keyword.control.conditional.recipe",
+	fillMarker: "keyword.operator.fill.recipe",
+	dtdKeyword: "keyword.operator.dtd.recipe",
+	number: "constant.numeric.recipe",
+	unit: "support.type.unit.recipe",
+	lineComment: "comment.line.number-sign.recipe",
+	docCommentLine: "comment.line.documentation.recipe",
+	blockComment: "comment.block.recipe",
+	docCommentBlock: "comment.block.documentation.recipe",
+	punctuation: "punctuation.separator.recipe",
+	ingredientWord: "variable.other.ingredient.recipe",
+	signaWord: "string.unquoted.signa.recipe",
+	dispenseWord: "variable.other.dispense.recipe"
+};
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+const escapeRegex = (s) => s.replace(REGEX_METACHARS, "\\$&");
+const alt = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+const altMultiword = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map((s) => s.replace(/\./g, "\\.").replace(/\s+/g, "\\s+")).join("|");
+const wb = (pattern) => `(?<![\\w.])(?:${pattern})(?![\\w.])`;
+function buildGrammar() {
+	const doseMatch = {
+		match: `(\\d+(?:[.,]\\d+)?)\\s*(${alt(UNITS)})(?![A-Za-zÀ-ÿ])`,
+		captures: {
+			"1": { name: SCOPE.number },
+			"2": { name: SCOPE.unit }
+		}
+	};
+	const bareNumber = {
+		match: "\\d+(?:[.,]\\d+)?",
+		name: SCOPE.number
+	};
+	const compactFrequency = {
+		match: "[1-9]\\s*dd(?![A-Za-zÀ-ÿ0-9])",
+		name: SCOPE.frequency
+	};
+	const fillTo = {
+		match: "\\bad\\b(?=\\s+\\d)",
+		name: SCOPE.fillMarker
+	};
+	const dtdDirective = {
+		match: "(?i)(?<![\\w.])(d\\.?t\\.?d\\.?)(?:\\s+(no))?(?=\\s+\\d)",
+		captures: {
+			"1": { name: SCOPE.dtdKeyword },
+			"2": { name: SCOPE.dtdKeyword }
+		}
+	};
+	const warningAbbrev = {
+		match: wb(alt(WARNING)),
+		name: SCOPE.warning
+	};
+	const latinAbbrevs = [
+		{
+			match: wb(altMultiword(TIMING_MULTIWORD)),
+			name: SCOPE.timing
+		},
+		{
+			match: wb(altMultiword(ROUTE_MULTIWORD)),
+			name: SCOPE.route
+		},
+		{
+			match: wb(altMultiword(DISPENSING_MULTIWORD)),
+			name: SCOPE.dispensing
+		},
+		{
+			match: wb(altMultiword(FORMS_MULTIWORD)),
+			name: SCOPE.form
+		},
+		{
+			match: wb(altMultiword(COMPOUNDING_MULTIWORD)),
+			name: SCOPE.compounding
+		},
+		{
+			match: wb(altMultiword(CONDITIONAL_MULTIWORD)),
+			name: SCOPE.conditional
+		},
+		{
+			match: wb(alt(FREQUENCY)),
+			name: SCOPE.frequency
+		},
+		{
+			match: wb(alt(TIMING)),
+			name: SCOPE.timing
+		},
+		{
+			match: wb(alt(ROUTE)),
+			name: SCOPE.route
+		},
+		{
+			match: wb(alt(DISPENSING)),
+			name: SCOPE.dispensing
+		},
+		{
+			match: wb(alt(FORMS)),
+			name: SCOPE.form
+		},
+		{
+			match: wb(alt(COMPOUNDING)),
+			name: SCOPE.compounding
+		},
+		{
+			match: wb(alt(CONDITIONAL)),
+			name: SCOPE.conditional
+		}
+	];
+	const punctuation = {
+		match: "[-.,;:()]",
+		name: SCOPE.punctuation
+	};
+	const comments = [
+		{
+			name: SCOPE.docCommentBlock,
+			begin: "/\\*\\*",
+			end: "\\*/"
+		},
+		{
+			name: SCOPE.blockComment,
+			begin: "/\\*",
+			end: "\\*/"
+		},
+		{
+			name: SCOPE.docCommentLine,
+			match: "#!.*$"
+		},
+		{
+			name: SCOPE.lineComment,
+			match: "#.*$"
+		}
+	];
+	const period = alt(PERIODS);
+	const dutchFrequency = [
+		{
+			match: `(?i)\\bom[ \\t]+de(?:[ \\t]+andere)?(?:[ \\t]+\\d+)?[ \\t]+(?:${alt([...PERIOD_PLURALS, ...PERIODS])})\\b`,
+			name: SCOPE.frequency
+		},
+		{
+			match: `(?i)\\b\\d+[ \\t]*(?:${alt(COUNTERS)})[ \\t]+(?:per[ \\t]+(?:${period})|daags)\\b`,
+			name: SCOPE.frequency
+		},
+		{
+			match: `(?i)\\b(?:${alt(NUMBER_WORDS)})[ \\t]*maal(?:[ \\t]+(?:daags|per[ \\t]+(?:${period})))?\\b`,
+			name: SCOPE.frequency
+		}
+	];
+	const sharedAtoms = [
+		...comments,
+		warningAbbrev,
+		dtdDirective,
+		fillTo,
+		compactFrequency,
+		...dutchFrequency,
+		doseMatch,
+		...latinAbbrevs,
+		bareNumber,
+		punctuation
+	];
+	/**
+	* Sections end only at the literal next marker (R/, Da/, D/, S/) or EOF.
+	* The trailing slash is load-bearing: without it, `s\b` inside `s.o.s.`
+	* would spuriously close a signa section because `.` is non-word.
+	*/
+	const nextSection = "(?i)(?=R/|Da?/|S/)|\\z";
+	const makeSection = (begin, marker, wordScope) => ({
+		name: `meta.section.${wordScope.split(".")[2] ?? "unknown"}.recipe`,
+		begin,
+		beginCaptures: { "0": { name: marker } },
+		end: nextSection,
+		patterns: [...sharedAtoms, {
+			match: "[A-Za-zÀ-ÿ][A-Za-zÀ-ÿ0-9\\-]*",
+			name: wordScope
+		}]
+	});
+	const rxSection = makeSection("(?i)R/", SCOPE.rxMarker, SCOPE.ingredientWord);
+	const dispenseSection = makeSection("(?i)Da?/", SCOPE.dispenseMarker, SCOPE.dispenseWord);
+	const signaSection = makeSection("(?i)S/", SCOPE.signaMarker, SCOPE.signaWord);
+	const grammar = {
+		$schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+		name: "Recipe",
+		scopeName: "source.recipe",
+		fileTypes: ["recipe"],
+		patterns: [
+			...comments,
+			rxSection,
+			dispenseSection,
+			signaSection,
+			warningAbbrev
+		],
+		repository: {
+			comments: { patterns: comments },
+			"shared-atoms": { patterns: sharedAtoms }
+		}
+	};
+	return {
+		grammar,
+		stats: {
+			topLevelPatterns: countPatterns(grammar.patterns),
+			vocab: {
+				frequency: FREQUENCY.length,
+				timing: {
+					single: TIMING.length,
+					multi: TIMING_MULTIWORD.length
+				},
+				route: {
+					single: ROUTE.length,
+					multi: ROUTE_MULTIWORD.length
+				},
+				dispensing: {
+					single: DISPENSING.length,
+					multi: DISPENSING_MULTIWORD.length
+				},
+				forms: {
+					single: FORMS.length,
+					multi: FORMS_MULTIWORD.length
+				},
+				compounding: {
+					single: COMPOUNDING.length,
+					multi: COMPOUNDING_MULTIWORD.length
+				},
+				conditional: {
+					single: CONDITIONAL.length,
+					multi: CONDITIONAL_MULTIWORD.length
+				},
+				warning: WARNING.length,
+				units: UNITS.length
+			}
+		}
+	};
+}
+function countPatterns(patterns) {
+	let n = 0;
+	for (const p of patterns) {
+		n += 1;
+		if ("patterns" in p && p.patterns) n += countPatterns(p.patterns);
+	}
+	return n;
+}
+function serializeGrammar(g, indent) {
+	return `${JSON.stringify(g, null, indent === "tab" ? "	" : indent)}\n`;
+}
+//#endregion
+//#region src/verifier.ts
+/**
+* @file Pure verifier — tokenizes tree-sitter-recipe's own highlight fixtures
+* with the generated TextMate grammar and reports whether each caret assertion
+* lands on a matching scope.
+*
+* No CLI concerns here; the caller supplies paths and decides how to present
+* the result (text table / JSON / exit code).
+*/
+const require = createRequire(import.meta.url);
+const oniguruma = require("vscode-oniguruma");
+const { parseRawGrammar, Registry } = require("vscode-textmate");
+const CAPTURE_EXPECTS = {
+	"keyword.directive": "keyword.control.directive",
+	"keyword.repeat": "keyword.other.frequency",
+	"keyword.error": "invalid.illegal.warning",
+	"keyword.operator": "keyword.operator",
+	"keyword.conditional": "keyword.control.conditional",
+	"keyword": "keyword.other.timing",
+	"function.macro": "support.function.route",
+	"attribute": "entity.other.attribute-name",
+	"type": "storage.type.form",
+	"type.builtin": "support.type.unit",
+	"number": "constant.numeric",
+	"variable": "variable.other.ingredient",
+	"string": "string.unquoted.signa",
+	"comment": "comment",
+	"comment.documentation": "comment",
+	"punctuation.delimiter": "punctuation.separator"
+};
+const ASSERT_RE = /^\s*#\s*(<-|\^+)\s+([\w.]+)\s*$/;
+const COMMENT_ONLY_RE = /^\s*#/;
+function parseFixture(content, name) {
+	const rawLines = content.split(/\r?\n/);
+	const sourceLines = [];
+	const asserts = [];
+	const sourceLineIndexForRawLine = [];
+	for (const raw of rawLines) if (!COMMENT_ONLY_RE.test(raw)) {
+		sourceLines.push(raw);
+		sourceLineIndexForRawLine.push(sourceLines.length);
+	} else sourceLineIndexForRawLine.push(sourceLines.length);
+	for (let i = 0; i < rawLines.length; i++) {
+		const raw = rawLines[i] ?? "";
+		if (!COMMENT_ONLY_RE.test(raw)) continue;
+		const match = raw.match(ASSERT_RE);
+		if (!match) continue;
+		const [, kind, capture] = match;
+		if (!kind || !capture) continue;
+		const targetLine = sourceLineIndexForRawLine[i] ?? 0;
+		if (targetLine === 0) continue;
+		const col = kind === "<-" ? 0 : raw.indexOf("^");
+		asserts.push({
+			fixture: name,
+			targetLine,
+			col,
+			capture
+		});
+	}
+	return {
+		source: sourceLines.join("\n"),
+		asserts
+	};
+}
+async function verify(opts) {
+	const wasmBin = readFileSync(opts.onigWasmPath);
+	await oniguruma.loadWASM(wasmBin.buffer);
+	const onigLib = Promise.resolve({
+		createOnigScanner: (patterns) => new oniguruma.OnigScanner(patterns),
+		createOnigString: (s) => new oniguruma.OnigString(s)
+	});
+	const rawGrammar = parseRawGrammar(readFileSync(opts.grammarPath, "utf-8"), opts.grammarPath);
+	const grammar = await new Registry({
+		onigLib,
+		loadGrammar: async () => null
+	}).addGrammar(rawGrammar);
+	const result = {
+		pass: 0,
+		total: 0,
+		failures: []
+	};
+	for (const name of readdirSync(opts.fixturesDir).sort()) {
+		if (!name.endsWith(".recipe")) continue;
+		const { source, asserts } = parseFixture(readFileSync(resolve(opts.fixturesDir, name), "utf-8"), name);
+		const sourceLines = source.split("\n");
+		let ruleStack = null;
+		const perLine = [];
+		for (const line of sourceLines) {
+			const r = grammar.tokenizeLine(line, ruleStack);
+			perLine.push(r.tokens.map((t) => ({
+				start: t.startIndex,
+				end: t.endIndex,
+				scopes: [...t.scopes]
+			})));
+			ruleStack = r.ruleStack;
+		}
+		for (const a of asserts) {
+			result.total += 1;
+			const tokens = perLine[a.targetLine - 1];
+			const hit = tokens?.find((t) => a.col >= t.start && a.col < t.end) ?? tokens?.find((t) => a.col === t.end);
+			const expected = CAPTURE_EXPECTS[a.capture];
+			if (!!(hit && expected && hit.scopes.some((s) => s.startsWith(expected)))) result.pass += 1;
+			else result.failures.push({
+				fixture: a.fixture,
+				line: a.targetLine,
+				col: a.col,
+				capture: a.capture,
+				got: hit ? hit.scopes : null
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+//#region package.json
+var version = "0.3.3";
+var homepage = "https://github.com/kjanat/recipe-tmlanguage#recipe-tmlanguage";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/kjanat/recipe-tmlanguage.git"
+};
+//#endregion
+//#region bin/recipe-tmlang.ts
+/**
+* recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
+*
+* Subcommands
+* - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
+* - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
+*
+* Zero manual argparse — argument parsing, help, and completions all come from
+* {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
+* we branch on {@linkcode Out.jsonMode}.
+*/
+const DEFAULT_OUT = `${resolve(import.meta.dirname, "..")}/recipe.tmLanguage.json`;
+const DEFAULT_FIXTURES_DIR = resolve(resolve(dirname(fileURLToPath(import.meta.resolve("tree-sitter-recipe/package.json")))), "test/highlight");
+const DEFAULT_ONIG_WASM = fileURLToPath(import.meta.resolve("vscode-oniguruma/release/onig.wasm"));
+const indentOf = (raw) => raw === "tab" ? "tab" : Number(raw);
+const generate = command("generate").description("Build the TextMate grammar from the tree-sitter-recipe vocabulary").flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path")).flag("indent", flag.enum([
+	"tab",
+	"2",
+	"4"
+]).default("tab").describe("JSON indent")).flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success")).action(({ flags, out }) => {
+	const { grammar, stats } = buildGrammar();
+	const serialized = serializeGrammar(grammar, indentOf(flags.indent));
+	const outAbs = resolve(cwd(), flags.out);
+	mkdirSync(dirname(outAbs), { recursive: true });
+	writeFileSync(outAbs, serialized);
+	if (out.jsonMode) {
+		out.json({
+			ok: true,
+			outPath: outAbs,
+			bytes: serialized.length,
+			stats
+		});
+		return;
+	}
+	if (flags.quiet) return;
+	out.log(`wrote ${outAbs}`);
+	out.log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
+	const v = stats.vocab;
+	out.log(`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`);
+});
+const verifyCmd = command("verify").description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches").flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json")).flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures")).flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM")).flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)")).action(async ({ flags, out }) => {
+	const result = await verify({
+		grammarPath: resolve(cwd(), flags.grammar),
+		fixturesDir: resolve(cwd(), flags.fixtures),
+		onigWasmPath: resolve(cwd(), flags["onig-wasm"])
+	});
+	const failuresLen = result.failures.length;
+	if (out.jsonMode) {
+		out.json(result);
+		if (failuresLen > 0) {
+			out.setExitCode(1);
+			exit();
+		}
+		return;
+	}
+	out.log(`${result.pass} / ${result.total} assertions pass`);
+	if (failuresLen === 0) return;
+	out.log("");
+	out.log("── failures ──");
+	const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
+	for (const f of result.failures.slice(0, limit)) {
+		const gotStr = f.got ? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)" : "(no token)";
+		out.log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
+	}
+	if (failuresLen > limit) out.log(`  … +${failuresLen - limit} more`);
+	out.setExitCode(1);
+});
+const app = cli("recipe-tmlang").packageJson({
+	repository,
+	homepage,
+	version
+}).links().description("TextMate grammar generator & verifier for the recipe DSL").command(generate).command(verifyCmd).completions();
+if (import.meta.main) app.run();
+//#endregion
+export { app };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "recipe-tmlanguage",
-	"version": "0.3.2",
+	"version": "0.3.3",
 	"description": "TextMate grammar for the recipe (.recipe) pharmacological notation language.",
 	"keywords": [
 		"dreamcli",