@mrhenry/twig-html-parser 0.1.0

package/test/twig-html-parser.test.js

@@ -0,0 +1,176 @@
+// @ts-check
+/**
+ * Structure and position tests for the `@mrhenry/twig-html-parser` hybrid AST
+ * builder.
+ *
+ * The hybrid tree must reflect the source structure exactly: elements nest as
+ * written, twig leaves appear in data/attribute positions, and twig block tags
+ * pair into `twigBlock` nodes with their bodies. Node offsets must match the
+ * original source (the basis for report-only / range / cursor modes).
+ *
+ * @module test
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parse } from '@mrhenry/twig-html-parser';
+
+/**
+ * @param {string} source
+ * @returns {any}
+ */
+function ast(source) {
+	return parse(source, 'index.twig');
+}
+
+/**
+ * @param {any} root
+ * @param {string} type
+ * @returns {Array<any>}
+ */
+function findAll(root, type) {
+	/** @type {Array<any>} */
+	const found = [];
+	const walk = (/** @type {any} */ n) => {
+		if (n.type === type) {
+			found.push(n);
+		}
+		if (n.children) {
+			for (const c of n.children) {
+				walk(c);
+			}
+		}
+	};
+	walk(root);
+	return found;
+}
+
+/**
+ * Asserts node offsets line up with the source.
+ *
+ * @param {any} root
+ * @param {string} source
+ */
+function assertOffsetsInSource(root, source) {
+	const walk = (/** @type {any} */ n) => {
+		assert.ok(n.rawStart >= 0 && n.rawEnd <= source.length, `${n.type} out of range`);
+		assert.ok(n.rawStart <= n.rawEnd, `${n.type} reversed`);
+		if (n.raw) {
+			assert.equal(source.slice(n.rawStart, n.rawEnd), n.raw, `${n.type} raw mismatch`);
+		}
+		if (n.children) {
+			for (const c of n.children) {
+				walk(c);
+			}
+		}
+	};
+	walk(root);
+}
+
+test('parses elements into a nested tree', () => {
+	const root = ast('<div><span>hi</span></div>');
+	assert.equal(root.type, 'root');
+	assert.equal(root.children.length, 1);
+	const div = root.children[0];
+	assert.equal(div.type, 'element');
+	assert.equal(div.name, 'div');
+	assert.equal(div.children[0].type, 'element');
+	assert.equal(div.children[0].name, 'span');
+	assert.equal(div.children[0].children[0].raw, 'hi');
+});
+
+test('parses a twig print in an attribute value', () => {
+	const root = ast('<a href="{{ url }}">x</a>');
+	const a = root.children[0];
+	assert.equal(a.attrs.length, 1);
+	const attr = /** @type {any} */ (a.attrs[0]);
+	assert.equal(attr.nameRaw, 'href');
+	assert.equal(attr.valueChunks[0].type, 'twig');
+});
+
+test('pairs conditional attributes into a twigBlock inside a start tag', () => {
+	const root = ast('<div class="row" {% if x %} id="y" {% endif %} data-x>');
+	const div = root.children[0];
+	const kinds = div.attrs.map((/** @type {any} */ a) => a.type ?? 'attr');
+	assert.deepEqual(kinds, ['attr', 'twigBlock', 'attr']);
+	const block = /** @type {any} */ (div.attrs[1]);
+	assert.equal(block.tag, 'if');
+	assert.equal(block.open.raw, '{% if x %}');
+	assert.equal(block.close.raw, '{% endif %}');
+	assert.equal(block.children.length, 1);
+});
+
+test('pairs a twig block in text position', () => {
+	const root = ast('{% if x %}<p>a</p>{% endif %}');
+	assert.equal(root.children.length, 1);
+	const block = root.children[0];
+	assert.equal(block.type, 'twigBlock');
+	assert.equal(block.tag, 'if');
+	assert.equal(block.children.length, 1);
+	assert.equal(block.children[0].type, 'element');
+});
+
+test('splits else sections', () => {
+	const root = ast('{% if x %}a{% else %}b{% endif %}');
+	const block = root.children[0];
+	assert.equal(block.sections.length, 2);
+	assert.equal(block.sections[0].head, null);
+	assert.equal(block.sections[0].body[0].raw, 'a');
+	assert.equal(block.sections[1].head.raw, '{% else %}');
+	assert.equal(block.sections[1].body[0].raw, 'b');
+});
+
+test('keeps a leaf for a set without a body', () => {
+	const root = ast('{% set x = 1 %}{{ x }}');
+	assert.equal(root.children[0].type, 'twig');
+	assert.equal(root.children[1].type, 'twig');
+});
+
+test('pairs a capture set', () => {
+	const root = ast('{% set x %}hi{% endset %}');
+	assert.equal(root.children[0].type, 'twigBlock');
+	assert.equal(root.children[0].tag, 'set');
+	assert.equal(root.children[0].children[0].raw, 'hi');
+});
+
+test('keeps raw text element content intact', () => {
+	const root = ast('<script>var x = "{{ v }}";</script>');
+	const script = root.children[0];
+	assert.equal(script.name, 'script');
+	assert.deepEqual(script.children.map((/** @type {any} */ c) => c.type), ['text', 'twig', 'text']);
+});
+
+test('keeps html comments and doctype', () => {
+	const root = ast('<!doctype html><!-- c --><p>x</p>');
+	assert.deepEqual(root.children.map((/** @type {any} */ c) => c.type), ['doctype', 'comment', 'element']);
+	assert.equal(root.children[1].raw, '<!-- c -->');
+});
+
+test('keeps twig comments', () => {
+	const root = ast('{# note #}<p>x</p>');
+	assert.deepEqual(root.children.map((/** @type {any} */ c) => c.type), ['twigComment', 'element']);
+	assert.equal(root.children[0].raw, '{# note #}');
+});
+
+test('node raw offsets match the source', () => {
+	const source = '<div class="row" {% if x %} id="{{ id }}" {% endif %}>\n\t<p>hi</p>\n</div>\n{% if y %}x{% endif %}';
+	const root = ast(source);
+	assertOffsetsInSource(root, source);
+});
+
+test('node raw offsets match the source across nesting', () => {
+	const source = '{% for i in items %}\n\t<a href="{{ i.url }}">{{ i.title }}</a>\n{% endfor %}';
+	const root = ast(source);
+	assertOffsetsInSource(root, source);
+});
+
+test('twig block indentation spans are contiguous with source', () => {
+	const source = 'a{% if x %}b{% else %}c{% endif %}d';
+	const root = ast(source);
+	const texts = findAll(root, 'text');
+	assert.deepEqual(texts.map((/** @type {any} */ t) => t.raw), ['a', 'b', 'c', 'd']);
+	assertOffsetsInSource(root, source);
+});
+
+test('parser summary', () => {
+	assert.ok(true);
+});