RubyGems - presently - Versions diffs - 0.1.0 - Mend

presently 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (215) hide show

data/public/_components/@socketry/syntax/test/Syntax/Language/sql.js ADDED Viewed

@@ -0,0 +1,281 @@
+/**
+ * Tests for SQL language syntax highlighting
+ */
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {JSDOM} from 'jsdom';
+import Syntax from '../../../Syntax.js';
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.customElements = dom.window.customElements;
+const syntax = new Syntax();
+test('SQL language can be registered', async () => {
+	const language = await syntax.getResource('sql');
+	assert.ok(language);
+	assert.equal(language.name, 'sql');
+});
+test('SQL can match SELECT keyword', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(syntax, 'SELECT * FROM users');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'SELECT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'FROM'));
+});
+test('SQL can match INSERT keyword', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'INSERT INTO users VALUES (1, 2)'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'INSERT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'INTO'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'VALUES'));
+});
+test('SQL can match UPDATE keyword', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'UPDATE users SET name = "John"'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'UPDATE'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'SET'));
+});
+test('SQL can match DELETE keyword', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'DELETE FROM users WHERE id = 1'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'DELETE'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'WHERE'));
+});
+test('SQL can match CREATE TABLE', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'CREATE TABLE users (id INT PRIMARY KEY)'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'CREATE'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'TABLE'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'PRIMARY'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'KEY'));
+});
+test('SQL can match JOIN keywords', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT * FROM a LEFT JOIN b ON a.id = b.id'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'LEFT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'JOIN'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'ON'));
+});
+test('SQL can match operators', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'WHERE a = 1 AND b != 2 OR c > 3'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '='));
+	assert.ok(operators.some(m => m.value === '!='));
+	assert.ok(operators.some(m => m.value === '>'));
+});
+test('SQL can match comparison operators', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'WHERE x < 5 AND y >= 10 AND z <= 20'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '<'));
+	assert.ok(operators.some(m => m.value === '>='));
+	assert.ok(operators.some(m => m.value === '<='));
+});
+test('SQL can match arithmetic operators', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT a + b - c * d / e % f'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '+'));
+	assert.ok(operators.some(m => m.value === '-'));
+	assert.ok(operators.some(m => m.value === '*'));
+	assert.ok(operators.some(m => m.value === '/'));
+	assert.ok(operators.some(m => m.value === '%'));
+});
+test('SQL can match single-line comments', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'-- This is a comment\nSELECT * FROM users'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '-- This is a comment'));
+});
+test('SQL can match single-quoted strings', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		"SELECT * FROM users WHERE name = 'John Doe'"
+	);
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === "'John Doe'"));
+});
+test('SQL can match double-quoted strings', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT * FROM users WHERE name = "Jane Smith"'
+	);
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === '"Jane Smith"'));
+});
+test('SQL can match decimal numbers', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT * FROM items WHERE price = 19.99'
+	);
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '19.99'));
+});
+test('SQL can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(syntax, 'SELECT 0xFF, 0x1A2B');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '0xFF'));
+	assert.ok(numbers.some(m => m.value === '0x1A2B'));
+});
+test('SQL keywords are case-insensitive', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'select * from users where id = 1'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'select'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'from'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'where'));
+});
+test('SQL can match data types', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'CREATE TABLE t (id INT, name VARCHAR, created TIMESTAMP)'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'INT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'VARCHAR'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'TIMESTAMP'));
+});
+test('SQL can match aggregate functions', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT COUNT(*), SUM(price), AVG(rating) FROM items'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'COUNT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'SUM'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'AVG'));
+});
+test('SQL can match GROUP BY and HAVING', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT category FROM items GROUP BY category HAVING COUNT(*) > 5'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'GROUP'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'BY'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'HAVING'));
+});
+test('SQL can match ORDER BY', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT * FROM users ORDER BY name ASC, age DESC'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'ORDER'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'BY'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'ASC'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'DESC'));
+});
+test('SQL can match DISTINCT keyword', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT DISTINCT category FROM items'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'DISTINCT'));
+});
+test('SQL can match LIMIT and OFFSET', async () => {
+	const language = await syntax.getResource('sql');
+	const matches = await language.getMatches(
+		syntax,
+		'SELECT * FROM users LIMIT 10 OFFSET 20'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'LIMIT'));
+	assert.ok(keywords.some(m => m.value.toUpperCase() === 'OFFSET'));
+});
+test('SQL can process complete query', async () => {
+	const language = await syntax.getResource('sql');
+	const code = `-- Get active users with their order counts
+SELECT
+	u.id,
+	u.name,
+	COUNT(o.id) AS order_count
+FROM users u
+LEFT JOIN orders o ON u.id = o.user_id
+WHERE u.active = 1
+GROUP BY u.id, u.name
+HAVING COUNT(o.id) > 0
+ORDER BY order_count DESC
+LIMIT 100;`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.length > 0);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.length > 0);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/super-collider.js ADDED Viewed

@@ -0,0 +1,66 @@
+import Syntax from '../../../Syntax.js';
+import registerSuperCollider from '../../../Syntax/Language/super-collider.js';
+import {strictEqual} from 'node:assert';
+import test from 'node:test';
+async function getTypesFor(code) {
+	const syntax = new Syntax();
+	registerSuperCollider(syntax);
+	const language = await syntax.getLanguage('super-collider');
+	const matches = await language.getMatches(syntax, code);
+	return matches.map(m => m.expression.type);
+}
+test('SuperCollider: keywords', async () => {
+	const types = await getTypesFor('var x; classvar y; const z; arg a;');
+	strictEqual(types.includes('keyword'), true);
+});
+test('SuperCollider: operators', async () => {
+	const types = await getTypesFor(
+		'a+b - c * d / e % f < g > h = i & j | k ~ l ! m : n @ o'
+	);
+	strictEqual(types.includes('operator'), true);
+});
+test('SuperCollider: values/constants', async () => {
+	const types = await getTypesFor(
+		'thisFunction thisMethod thisProcess thisThread this super true false nil inf'
+	);
+	strictEqual(types.filter(t => t === 'constant').length >= 3, true);
+});
+test('SuperCollider: camel case type', async () => {
+	const types = await getTypesFor('SynthDef EnvGen Pan2 SinOsc');
+	strictEqual(types.includes('type'), true);
+});
+test('SuperCollider: single character constants', async () => {
+	const types = await getTypesFor('$a $\n');
+	strictEqual(types.includes('constant'), true);
+});
+test('SuperCollider: symbols', async () => {
+	const types1 = await getTypesFor('\\freq \\amp');
+	strictEqual(types1.includes('symbol'), true);
+	const types2 = await getTypesFor("'foo' 'bar'");
+	strictEqual(types2.includes('symbol'), true);
+});
+test('SuperCollider: comments and links', async () => {
+	const types = await getTypesFor('/* comment */ // line http://example.com');
+	strictEqual(types.includes('comment'), true);
+	strictEqual(types.includes('href'), true);
+});
+test('SuperCollider: strings and numbers', async () => {
+	const types = await getTypesFor('\'a\' "b" 0xFF 123 3.14');
+	// 'a' is a Symbol (handled in the symbols test). Only \"b\" is a String.
+	strictEqual(types.filter(t => t === 'string').length >= 1, true);
+	strictEqual(types.filter(t => t === 'constant').length >= 2, true);
+});
+test('SuperCollider: method calls and functions', async () => {
+	const types = await getTypesFor('object.method(); func()');
+	strictEqual(types.includes('function'), true);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/swift.js ADDED Viewed

@@ -0,0 +1,71 @@
+/**
+ * Tests for Swift language syntax highlighting
+ */
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {JSDOM} from 'jsdom';
+import Syntax from '../../../Syntax.js';
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.customElements = dom.window.customElements;
+const syntax = new Syntax();
+test('Swift language can be registered', async () => {
+	const language = await syntax.getResource('swift');
+	assert.ok(language);
+	assert.equal(language.name, 'swift');
+});
+test('Swift can match keywords', async () => {
+	const language = await syntax.getResource('swift');
+	const matches = await language.getMatches(
+		syntax,
+		'class MyClass func test() { if true { } }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'class'));
+	assert.ok(keywords.some(m => m.value === 'func'));
+	assert.ok(keywords.some(m => m.value === 'if'));
+});
+test('Swift can match access modifiers', async () => {
+	const language = await syntax.getResource('swift');
+	const matches = await language.getMatches(
+		syntax,
+		'public class A private var b'
+	);
+	const access = matches.filter(m => m.type === 'access');
+	assert.ok(access.some(m => m.value === 'public'));
+	assert.ok(access.some(m => m.value === 'private'));
+});
+test('Swift can match constants', async () => {
+	const language = await syntax.getResource('swift');
+	const matches = await language.getMatches(
+		syntax,
+		'let a = true, b = false, c = nil'
+	);
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'true'));
+	assert.ok(constants.some(m => m.value === 'false'));
+	assert.ok(constants.some(m => m.value === 'nil'));
+});
+test('Swift can match backtick identifiers', async () => {
+	const language = await syntax.getResource('swift');
+	const matches = await language.getMatches(syntax, 'let `class` = "test"');
+	const identifiers = matches.filter(m => m.type === 'identifier');
+	assert.ok(identifiers.some(m => m.value === '`class`'));
+});
+test('Swift can match arrow operator', async () => {
+	const language = await syntax.getResource('swift');
+	const matches = await language.getMatches(syntax, 'func foo() -> Int { }');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '->'));
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/xml.js ADDED Viewed

@@ -0,0 +1,170 @@
+/**
+ * Tests for XML language syntax highlighting
+ */
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {JSDOM} from 'jsdom';
+import Syntax from '../../../Syntax.js';
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.customElements = dom.window.customElements;
+const syntax = new Syntax();
+test('XML language can be registered', async () => {
+	const language = await syntax.getResource('xml');
+	assert.ok(language);
+	assert.equal(language.name, 'xml');
+});
+test('xml-tag language can be registered', async () => {
+	const language = await syntax.getResource('xml-tag');
+	assert.ok(language);
+	assert.equal(language.name, 'xml-tag');
+});
+test('XML can match opening tags', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<root>');
+	assert.ok(matches.some(m => m.value === '<root>'));
+});
+test('XML can match closing tags', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '</root>');
+	assert.ok(matches.some(m => m.value === '</root>'));
+});
+test('XML can match self-closing tags', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<element/>');
+	assert.ok(matches.some(m => m.value === '<element/>'));
+});
+test('XML can match tags with namespace', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<ns:element>');
+	assert.ok(matches.some(m => m.value === '<ns:element>'));
+});
+test('XML can match tags with attributes', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<element attr="value">');
+	assert.ok(matches.some(m => m.value === '<element attr="value">'));
+});
+test('XML can match entities', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '&nbsp; &lt; &gt; &amp;');
+	const entities = matches.filter(m => m.type === 'entity');
+	assert.ok(entities.some(m => m.value === '&nbsp;'));
+	assert.ok(entities.some(m => m.value === '&lt;'));
+	assert.ok(entities.some(m => m.value === '&gt;'));
+	assert.ok(entities.some(m => m.value === '&amp;'));
+});
+test('XML can match CDATA sections', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<![CDATA[some data]]>');
+	const cdata = matches.filter(m => m.type === 'cdata');
+	assert.ok(cdata.length > 0);
+});
+test('XML can match CDATA with special chars', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<![CDATA[<>&"\']]>');
+	const cdata = matches.filter(m => m.type === 'cdata');
+	assert.ok(cdata.length > 0);
+});
+test('XML can match comments', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '<!-- comment -->');
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.length > 0);
+});
+test('XML can match multi-line comments', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(
+		syntax,
+		'<!-- multi\nline\ncomment -->'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.length > 0);
+});
+test('XML can match percent escapes', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, '%20%2F%3A');
+	const escapes = matches.filter(m => m.type === 'percent-escape');
+	assert.ok(escapes.some(m => m.value === '%20'));
+	assert.ok(escapes.some(m => m.value === '%2F'));
+	assert.ok(escapes.some(m => m.value === '%3A'));
+});
+test('XML can match URLs', async () => {
+	const language = await syntax.getResource('xml');
+	const matches = await language.getMatches(syntax, 'http://example.com/path');
+	const urls = matches.filter(m => m.type === 'href');
+	assert.ok(urls.some(m => m.value === 'http://example.com/path'));
+});
+test('xml-tag can match tag names', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, '<element>');
+	const tagNames = matches.filter(m => m.type === 'tag-name');
+	assert.ok(tagNames.some(m => m.value === 'element'));
+});
+test('xml-tag can match namespaces', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, '<ns:element>');
+	const namespaces = matches.filter(m => m.type === 'namespace');
+	assert.ok(namespaces.some(m => m.value === 'ns:'));
+});
+test('xml-tag can match attributes', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, '<element attr="value">');
+	const attributes = matches.filter(m => m.type === 'attribute');
+	assert.ok(attributes.some(m => m.value === 'attr'));
+});
+test('xml-tag can match attribute values', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, '<element attr="value">');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === '"value"'));
+});
+test('xml-tag can match single-quoted attributes', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, "<element attr='value'>");
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === "'value'"));
+});
+test('xml-tag can match unquoted attributes', async () => {
+	const xmlTag = await syntax.getResource('xml-tag');
+	const matches = await xmlTag.getMatches(syntax, '<element attr=value>');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === 'value'));
+});
+test('XML can process complete document', async () => {
+	const language = await syntax.getResource('xml');
+	const code = `<?xml version="1.0"?>
+<root xmlns:ns="http://example.com">
+	<!-- Comment -->
+	<element attr="value">text &amp; entity</element>
+	<ns:element/>
+	<![CDATA[<raw>data</raw>]]>
+</root>`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/xrb.js ADDED Viewed

@@ -0,0 +1,57 @@
+import Syntax from '../../../Syntax.js';
+import registerXRB from '../../../Syntax/Language/xrb.js';
+import registerRuby from '../../../Syntax/Language/ruby.js';
+import registerXML from '../../../Syntax/Language/xml.js';
+import {strictEqual} from 'node:assert';
+import test from 'node:test';
+async function getMatches(code) {
+	const syntax = new Syntax();
+	registerRuby(syntax);
+	registerXML(syntax);
+	registerXRB(syntax);
+	const language = await syntax.getLanguage('xrb');
+	return await language.getMatches(syntax, code);
+}
+function typesFrom(matches) {
+	return matches.map(m => m.expression.type);
+}
+test('XRB: ruby processing instruction', async () => {
+	const matches = await getMatches('<?r puts "Hello" ?>');
+	const types = typesFrom(matches);
+	// Should include a keyword-class token for opening/closing and an embedded ruby subtree
+	strictEqual(
+		types.some(t => t.includes('keyword')),
+		true
+	);
+	strictEqual(
+		matches.some(m => m.expression && m.expression.language === 'ruby'),
+		true
+	);
+});
+test('XRB: interpolation #{...}', async () => {
+	const matches = await getMatches('Value: #{x + 1}');
+	const types = typesFrom(matches);
+	strictEqual(
+		types.some(t => t.includes('keyword')),
+		true
+	);
+	// Embedded ruby subtree should be present
+	strictEqual(
+		matches.some(m => m.expression && m.expression.language === 'ruby'),
+		true
+	);
+});
+test('XRB: xml context preserved', async () => {
+	const matches = await getMatches('<tag attr="v">#{1+2}</tag>');
+	const types = typesFrom(matches);
+	// Expect interpolation keyword to be present; XML tags are handled via subtree
+	strictEqual(
+		types.some(t => t.includes('keyword')),
+		true
+	);
+});