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/apache.js ADDED Viewed

@@ -0,0 +1,153 @@
+/**
+ * Tests for Apache language definition
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import {JSDOM} from 'jsdom';
+// Setup DOM environment
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.document = dom.window.document;
+import Syntax from '../../../Syntax.js';
+import registerApache from '../../../Syntax/Language/apache.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('Apache language can be registered', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'apache');
+});
+test('Apache can match opening tags', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '<VirtualHost *:80>';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'tag', '<VirtualHost *:80>');
+	assertToken(code, matches, 'tag-name', 'VirtualHost');
+});
+test('Apache can match closing tags', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '</VirtualHost>';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'tag', '</VirtualHost>');
+	assertToken(code, matches, 'tag-name', 'VirtualHost');
+});
+test('Apache can match directives', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '  ServerName example.com\n  DocumentRoot /var/www';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'function', 'ServerName');
+	assertToken(code, matches, 'function', 'DocumentRoot');
+});
+test('Apache can match comments', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '# This is a comment\nServerName example.com';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('#'));
+});
+test('Apache can match single-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = "ErrorLog 'logs/error.log'";
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', "'logs/error.log'");
+});
+test('Apache can match double-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = 'ErrorLog "logs/error.log"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', '"logs/error.log"');
+});
+test('Apache can match URLs', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = 'Redirect https://example.com/new';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'href', 'https://example.com/new');
+});
+test('Apache can process code to HTML', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '<VirtualHost *:80>\n  ServerName example.com\n</VirtualHost>';
+	const html = await language.process(syntax, code);
+	assert.ok(html.innerHTML.includes('tag'));
+	assert.ok(html.innerHTML.includes('VirtualHost'));
+	assert.ok(html.innerHTML.includes('function'));
+	assert.ok(html.innerHTML.includes('ServerName'));
+});
+test('Apache creates documentation links for directives', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = '  ServerName example.com';
+	const html = await language.process(syntax, code);
+	// Should have link to Apache documentation
+	const links = html.querySelectorAll('a.function');
+	assert.ok(links.length > 0);
+	assert.ok(links[0].href.includes('httpd.apache.org'));
+	assert.ok(links[0].href.includes('ServerName'));
+	assert.strictEqual(links[0].textContent, 'ServerName');
+});
+test('Apache can build a syntax tree', async () => {
+	const syntax = new Syntax();
+	registerApache(syntax);
+	const language = await syntax.getLanguage('apache');
+	const code = 'ServerName example.com';
+	const tree = await language.buildTree(syntax, code, 0);
+	assert.ok(tree);
+	assert.strictEqual(tree.offset, 0);
+	assert.strictEqual(tree.length, code.length);
+});

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

@@ -0,0 +1,198 @@
+/**
+ * Tests for AppleScript language definition
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import {JSDOM} from 'jsdom';
+// Setup DOM environment
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.document = dom.window.document;
+import Syntax from '../../../Syntax.js';
+import registerAppleScript from '../../../Syntax/Language/applescript.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('AppleScript language can be registered', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'applescript');
+});
+test('AppleScript can match basic keywords', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set x to 5\nreturn x';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'set');
+	assertToken(code, matches, 'keyword', 'to');
+	assertToken(code, matches, 'keyword', 'return');
+});
+test('AppleScript can match ordinal keywords', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'first item of myList';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'first');
+});
+test('AppleScript can match special keywords', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'activate application "Safari"\nset x to true\nset y to false';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'activate');
+	assertToken(code, matches, 'keyword', 'true');
+	assertToken(code, matches, 'keyword', 'false');
+});
+test('AppleScript can match double-dash comments', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = '-- This is a comment\nset x to 1';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('--'));
+});
+test('AppleScript can match hash comments', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = '# This is a comment\nset x to 1';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('#'));
+});
+test('AppleScript can match block comments', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = '(* This is a block comment *)\nset x to 1';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'comment', '(* This is a block comment *)');
+});
+test('AppleScript can match double-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set msg to "Hello World"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', '"Hello World"');
+});
+test('AppleScript can match ordinal numbers', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = '1st item, 2nd item, 3rd item, 4th item';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', '1st');
+	assertToken(code, matches, 'constant', '2nd');
+	assertToken(code, matches, 'constant', '3rd');
+	assertToken(code, matches, 'constant', '4th');
+});
+test('AppleScript can match decimal numbers', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set x to 42\nset y to 3.14';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', '42');
+	assertToken(code, matches, 'constant', '3.14');
+});
+test('AppleScript can match operators', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set x to 5 + 3 * 2';
+	const matches = await language.getMatches(syntax, code);
+	assertTokenCount(matches, 'operator', 2); // + and *
+});
+test('AppleScript can match control flow keywords', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'if x is equal to 5 then\nend if';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'if');
+	assertToken(code, matches, 'keyword', 'is equal to');
+});
+test('AppleScript can match URLs', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'open location "https://example.com"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'href', 'https://example.com');
+});
+test('AppleScript can process code to HTML', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set x to 5';
+	const html = await language.process(syntax, code);
+	assert.ok(html.innerHTML.includes('keyword'));
+	assert.ok(html.innerHTML.includes('set'));
+});
+test('AppleScript can build a syntax tree', async () => {
+	const syntax = new Syntax();
+	registerAppleScript(syntax);
+	const language = await syntax.getLanguage('applescript');
+	const code = 'set x to 5';
+	const tree = await language.buildTree(syntax, code, 0);
+	assert.ok(tree);
+	assert.strictEqual(tree.offset, 0);
+	assert.strictEqual(tree.length, code.length);
+});

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

@@ -0,0 +1,209 @@
+/**
+ * Tests for Assembly language definition
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import {JSDOM} from 'jsdom';
+// Setup DOM environment
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.document = dom.window.document;
+import Syntax from '../../../Syntax.js';
+import registerAssembly from '../../../Syntax/Language/assembly.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('Assembly language can be registered', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'assembly');
+});
+test('Assembly can be registered with asm alias', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('asm');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'assembly');
+});
+test('Assembly can match C-style comments', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '/* This is a comment */\nmov eax, ebx';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'comment', '/* This is a comment */');
+});
+test('Assembly can match C++-style comments', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '// This is a comment\nmov eax, ebx';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('//'));
+});
+test('Assembly can match directives', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '.text\n.global main\n.data';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'directive', '.text');
+	assertToken(code, matches, 'directive', '.global');
+	assertToken(code, matches, 'directive', '.data');
+});
+test('Assembly can match labels', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'main:\n  mov eax, 0\nloop_start:\n  inc eax';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'label', 'main:');
+	assertToken(code, matches, 'label', 'loop_start:');
+});
+test('Assembly can match instructions', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '  mov eax, ebx\n  add ecx, edx\n  ret';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'function', 'mov');
+	assertToken(code, matches, 'function', 'add');
+	assertToken(code, matches, 'function', 'ret');
+});
+test('Assembly can match registers', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'mov %eax, %ebx\nadd %ecx, %edx';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'register', '%eax');
+	assertToken(code, matches, 'register', '%ebx');
+	assertToken(code, matches, 'register', '%ecx');
+	assertToken(code, matches, 'register', '%edx');
+});
+test('Assembly can match decimal numbers', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'mov eax, 42\nadd ebx, -10';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', '42');
+	assertToken(code, matches, 'constant', '-10');
+});
+test('Assembly can match hexadecimal numbers', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'mov eax, 0xFF\nadd ebx, 0x10';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', '0xFF');
+	assertToken(code, matches, 'constant', '0x10');
+});
+test('Assembly can match single-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = "db 'Hello'";
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', "'Hello'");
+});
+test('Assembly can match double-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'db "World"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', '"World"');
+});
+test('Assembly can match hash comments', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '# This is a comment\nmov eax, ebx';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('#'));
+});
+test('Assembly can match URLs', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = '# See https://example.com/docs';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'href', 'https://example.com/docs');
+});
+test('Assembly can process code to HTML', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'main:\n  mov eax, 0\n  ret';
+	const html = await language.process(syntax, code);
+	assert.ok(html.innerHTML.includes('label'));
+	assert.ok(html.innerHTML.includes('main'));
+	assert.ok(html.innerHTML.includes('function'));
+	assert.ok(html.innerHTML.includes('mov'));
+});
+test('Assembly can build a syntax tree', async () => {
+	const syntax = new Syntax();
+	registerAssembly(syntax);
+	const language = await syntax.getLanguage('assembly');
+	const code = 'mov eax, 0';
+	const tree = await language.buildTree(syntax, code, 0);
+	assert.ok(tree);
+	assert.strictEqual(tree.offset, 0);
+	assert.strictEqual(tree.length, code.length);
+});