feat: add yaml enhanced mode with proper lazer grammar

Author: bajrangCoder

package.json

@@ -16,6 +16,7 @@
     "@lezer/common": "^1.5.2",
     "@lezer/highlight": "^1.2.3",
     "@lezer/lr": "^1.4.10",
+    "@lezer/yaml": "^1.0.4",
     "@replit/codemirror-lang-svelte": "^6.0.0",
     "@viz-js/lang-dot": "^1.0.5",
     "acode-plugin-types": "^1.11.7-patch.2",

plugin.json

@@ -17,7 +17,8 @@
         "autohotkey",
         "zig",
         "svelte",
-        "jsonc"
+        "jsonc",
+        "yaml"
     ],
     "price": 0,
     "permissions": [],

plugin.zip

@@ -12,6 +12,7 @@ Adds CodeMirror language support for languages that are not bundled with Acode.
 - Git attributes (`.gitattributes`, Git attributes-style files)
 - Git Commit Message (`^COMMIT_EDITMSG`, `^commit_editmsg`)
 - JSONC (`.jsonc`)
+- YAML Enhanced (`.yaml`, `.yml`), with structural parsing and core-schema scalar highlighting
 - BibTeX (`.bib`)
 - Elixir (`.ex`, `.exs`, `.eex`, `.heex`, `.leex`)
 - EJS (`.ejs`)

readme.md

@@ -179,6 +179,129 @@ for (const sample of jsoncSamples) {
 
 console.log(`Validated ${jsoncSamples.length} JSONC parser fixtures.`);
 
+const yamlBehaviorBundle = path.join(os.tmpdir(), "acode-yaml-behavior-test-bundle.mjs");
+const yamlBehaviorSource = String.raw`
+import assert from "node:assert/strict";
+import { EditorState } from "@codemirror/state";
+import { foldable, getIndentation, indentUnit, syntaxTree } from "@codemirror/language";
+import { classHighlighter, highlightTree } from "@lezer/highlight";
+import { yaml, yamlLanguage } from "./src/languages/yaml/index.js";
+
+const source = [
+  "%YAML 1.2",
+  "---",
+  "defaults: &defaults",
+  "  enabled: true",
+  "  retries: 3",
+  "  ratio: -1.25e+2",
+  "  missing: null",
+  "  image: ghcr.io/acme/app:latest",
+  "jobs:",
+  "  build:",
+  "    <<: *defaults",
+  "    runs-on: ubuntu-latest # runner label",
+  "    strategy: {matrix: {node: [18, 20]}}",
+  "    steps:",
+  "      - name: Test",
+  "        run: |-",
+  "          npm test # block scalar content",
+  "tagged: !!str value",
+  "...",
+  "",
+].join("\n");
+
+const tree = yamlLanguage.parser.parse(source);
+const names = new Set();
+const errors = [];
+tree.iterate({
+  enter(node) {
+    names.add(node.name);
+    if (node.type.isError) errors.push([node.from, node.to]);
+  },
+});
+
+assert.equal(errors.length, 0, "YAML fixture produced parse errors");
+for (const name of [
+  "Directive",
+  "BlockMapping",
+  "BlockSequence",
+  "FlowMapping",
+  "FlowSequence",
+  "BlockLiteral",
+  "Anchor",
+  "Alias",
+  "Tag",
+  "Boolean",
+  "Integer",
+  "Float",
+  "Null",
+  "PlainString",
+]) {
+  assert(names.has(name), "YAML fixture did not produce " + name);
+}
+
+const spans = [];
+highlightTree(tree, classHighlighter, (from, to, cls) => {
+  spans.push({ text: source.slice(from, to), cls });
+});
+
+function isHighlighted(text, tokenClass) {
+  return spans.some((span) => span.text === text && span.cls.includes(tokenClass));
+}
+
+assert(isHighlighted("defaults", "tok-propertyName"));
+assert(isHighlighted("true", "tok-bool"));
+assert(isHighlighted("3", "tok-number"));
+assert(isHighlighted("-1.25e+2", "tok-number"));
+assert(isHighlighted("null", "tok-keyword"));
+assert(isHighlighted("ubuntu-latest", "tok-string"));
+assert(isHighlighted("&defaults", "tok-labelName"));
+assert(isHighlighted("*defaults", "tok-labelName"));
+assert(isHighlighted("!!str", "tok-typeName"));
+assert(isHighlighted("# runner label", "tok-comment"));
+assert(!isHighlighted("# block scalar content", "tok-comment"));
+
+const indentSource = "jobs:\n  build:\n    steps:\n      - name: Test\n        run: npm test\n";
+const indentState = EditorState.create({
+  doc: indentSource,
+  extensions: [yaml(), indentUnit.of("  ")],
+});
+syntaxTree(indentState);
+assert.equal(getIndentation(indentState, indentState.doc.line(4).from), 4);
+assert.equal(getIndentation(indentState, indentState.doc.line(5).from), 8);
+assert(foldable(indentState, indentState.doc.line(1).from, indentState.doc.line(1).to));
+
+const flowSource = "matrix: {\n  node: [18, 20]\n}\n";
+const flowState = EditorState.create({
+  doc: flowSource,
+  extensions: [yaml(), indentUnit.of("  ")],
+});
+syntaxTree(flowState);
+assert.equal(getIndentation(flowState, flowState.doc.line(3).from), 0);
+
+console.log("Validated YAML parsing, highlighting, indentation, and folding fixtures.");
+`;
+
+await build({
+	stdin: {
+		contents: yamlBehaviorSource,
+		resolveDir: process.cwd(),
+		sourcefile: "yaml-behavior-test.mjs",
+		loader: "js",
+	},
+	bundle: true,
+	format: "esm",
+	platform: "node",
+	outfile: yamlBehaviorBundle,
+	logLevel: "silent",
+});
+
+try {
+	await import(pathToFileURL(yamlBehaviorBundle).href + `?t=${Date.now()}`);
+} finally {
+	fs.rmSync(yamlBehaviorBundle, { force: true });
+}
+
 const { parser: ejsParser } = await bundledRequire(
 	"src/languages/ejs/parser.js",
 	"acode-ejs-parser-test.cjs",
@@ -487,4 +610,3 @@ for (const sample of gleamSamples) {
 }
 
 console.log(`Validated ${gleamSamples.length} Gleam parser fixtures.`);
-

scripts/test-parser.mjs

@@ -19,8 +19,8 @@ const registered = [];
 const unregistered = [];
 
 const editorLanguages = {
-	get() {
-		return null;
+	get(name) {
+		return name === "yaml" ? { name: "yaml" } : null;
 	},
 	register(name, extensions, caption, load) {
 		registered.push({ name, extensions, caption, load });
@@ -56,6 +56,7 @@ async function test() {
 		"zig",
 		"gitignore",
 		"jsonc",
+		"yaml-enhanced",
 		"bibtex",
 		"elixir",
 		"golfscript",
@@ -80,6 +81,8 @@ async function test() {
 	assert(modes.get("zig").extensions.includes("zon"));
 	assert(modes.get("gitignore").extensions.includes("gitignore"));
 	assert(modes.get("jsonc").extensions.includes("jsonc"));
+	assert(modes.get("yaml-enhanced").extensions.includes("yaml"));
+	assert(modes.get("yaml-enhanced").extensions.includes("yml"));
 	assert(modes.get('gitcommitmsg').extensions.includes("^COMMIT_EDITMSG"));
 
 	const samples = {
@@ -116,6 +119,15 @@ message:
 		zig: 'const std = @import("std");',
 		gitignore: "# build output\ndist/\n!important.log\n*.tmp\n",
 		jsonc: '{\n  // comment\n  "foo": "bar",\n}',
+		"yaml-enhanced": `defaults: &defaults
+  enabled: true
+  retries: 3
+jobs:
+  build:
+    <<: *defaults
+    runs-on: ubuntu-latest
+    matrix: {node: [18, 20]}
+`,
 		bibtex: "@article{example, title={Example}}",
 		elixir: "defmodule Example do\nend",
 		golfscript: "1 2 +",
@@ -182,7 +194,7 @@ index 0000000..e69de29`
 		});
 		const tree = support.language.parser.parse(source);
 		assert.equal(tree.length, source.length, `${name} did not parse the full fixture`);
-		if (name === "asciidoc" || name === "assembly") {
+		if (name === "asciidoc" || name === "assembly" || name === "yaml-enhanced") {
 			const nodeNames = new Set();
 			const errors = [];
 			tree.iterate({
@@ -195,7 +207,9 @@ index 0000000..e69de29`
 			const expectedNodes =
 				name === "asciidoc"
 					? ["Heading1", "Heading2", "AttributeLine", "Xref", "ListingBlock", "ListItem"]
-					: ["DirectiveName", "Label", "Instruction", "Register", "String"];
+					: name === "assembly"
+						? ["DirectiveName", "Label", "Instruction", "Register", "String"]
+						: ["BlockMapping", "FlowMapping", "FlowSequence", "Anchor", "Alias", "Boolean", "Integer"];
 			for (const nodeName of expectedNodes) {
 				assert(
 					nodeNames.has(nodeName),

scripts/test-plugin-runtime.cjs

@@ -5,6 +5,7 @@ import { communityLanguageModes } from "./community";
 import { gitignoreMode } from "./gitignore";
 import { zigMode } from "./zig";
 import { jsoncMode } from "./jsonc";
+import { yamlMode } from "./yaml";
 
 import { ejsMode } from "./ejs"
 import { gitattributesMode } from "./gitattributes";
@@ -23,6 +24,7 @@ export const languageModes = [
 	zigMode,
 	gitignoreMode,
 	jsoncMode,
+	yamlMode,
 	...communityLanguageModes,
   ejsMode,
   gitattributesMode,

src/languages/index.js

@@ -0,0 +1,104 @@
+import {
+	delimitedIndent,
+	foldInside,
+	foldNodeProp,
+	indentNodeProp,
+	LanguageSupport,
+	LRLanguage,
+} from "@codemirror/language";
+import { parseMixed } from "@lezer/common";
+import { styleTags, tags as t } from "@lezer/highlight";
+import { parser as yamlParser } from "@lezer/yaml";
+import { parser as scalarParser } from "./parser";
+
+// @lezer/yaml provides an error-tolerant structural YAML parser. The nested
+// scalar parser retains that structure while distinguishing the core-schema
+// null, boolean, integer, float, and plain-string values described by the
+// tree-sitter YAML grammar.
+const configuredScalarParser = scalarParser.configure({
+	props: [
+		styleTags({
+			Null: t.null,
+			Boolean: t.bool,
+			"Integer Float": t.number,
+			PlainString: t.string,
+		}),
+	],
+});
+
+const configuredParser = yamlParser.configure({
+	wrap: parseMixed((node) => {
+		if (node.name !== "Literal" || node.node.parent?.name === "Key") {
+			return null;
+		}
+		return { parser: configuredScalarParser };
+	}),
+	props: [
+		indentNodeProp.add({
+			Stream: (context) => {
+				for (
+					let before = context.node.resolve(context.pos, -1);
+					before && before.to >= context.pos;
+					before = before.parent
+				) {
+					if (
+						before.name === "BlockLiteralContent" &&
+						before.from < before.to
+					) {
+						return context.baseIndentFor(before);
+					}
+					if (before.name === "BlockLiteral") {
+						return context.baseIndentFor(before) + context.unit;
+					}
+					if (
+						before.name === "BlockSequence" ||
+						before.name === "BlockMapping"
+					) {
+						return context.column(before.firstChild.from, 1);
+					}
+					if (before.name === "QuotedLiteral") return null;
+					if (before.name === "Literal") {
+						const column = context.column(before.from, 1);
+						if (column === context.lineIndent(before.from, 1)) return column;
+						if (before.to > context.pos) return null;
+					}
+				}
+				return null;
+			},
+			FlowMapping: delimitedIndent({ closing: "}" }),
+			FlowSequence: delimitedIndent({ closing: "]" }),
+		}),
+		foldNodeProp.add({
+			"FlowMapping FlowSequence": foldInside,
+			"Item Pair BlockLiteral": (node, state) => ({
+				from: state.doc.lineAt(node.from).to,
+				to: node.to,
+			}),
+		}),
+	],
+});
+
+export const yamlLanguage = LRLanguage.define({
+	name: "yaml",
+	parser: configuredParser,
+	languageData: {
+		commentTokens: { line: "#" },
+		closeBrackets: { brackets: ["[", "{", '"', "'"] },
+		indentOnInput: /^\s*[\]\}]$/,
+		wordChars: "-_",
+	},
+});
+
+export function yaml() {
+	return new LanguageSupport(yamlLanguage);
+}
+
+// Acode already owns the `yaml` registry key. Registering a distinct mode lets
+// this plugin coexist with it, while Acode's later-registration tie-breaker
+// selects this structured parser for .yaml and .yml files.
+export const yamlMode = {
+	name: "yaml-enhanced",
+	caption: "YAML (Enhanced)",
+	extensions: ["yaml", "yml"],
+	load: yaml,
+};

src/languages/yaml/index.js

@@ -0,0 +1,8 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+export const
+  Scalar = 1,
+  Null = 2,
+  Boolean = 3,
+  Float = 4,
+  Integer = 5,
+  PlainString = 6