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

@@ -0,0 +1,123 @@
+/**
+ * Tests for YAML 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 registerYaml from '../../../Syntax/Language/yaml.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('YAML language can be registered', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'yaml');
+});
+test('YAML can match comments', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = '# This is a comment\nkey: value';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('#'));
+});
+test('YAML can match single-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = "message: 'hello world'";
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', "'hello world'");
+});
+test('YAML can match double-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'message: "hello world"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', '"hello world"');
+});
+test('YAML can match anchors and aliases', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'anchor: &ref value\nalias: *ref';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', '&ref');
+	assertToken(code, matches, 'constant', '*ref');
+});
+test('YAML can match keys', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'name: John\nage: 30';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'name');
+	assertToken(code, matches, 'keyword', 'age');
+});
+test('YAML can match URLs', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'url: https://example.com/path';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'href', 'https://example.com/path');
+});
+test('YAML can process code to HTML', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'name: John';
+	const html = await language.process(syntax, code);
+	assert.ok(html.innerHTML.includes('keyword'));
+	assert.ok(html.innerHTML.includes('name'));
+});
+test('YAML can build a syntax tree', async () => {
+	const syntax = new Syntax();
+	registerYaml(syntax);
+	const language = await syntax.getLanguage('yaml');
+	const code = 'key: value';
+	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.js ADDED Viewed

@@ -0,0 +1,62 @@
+/**
+ * Tests for Language class
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import Syntax from '../../Syntax.js';
+import {Language} from '../../Syntax/Language.js';
+test('Language can be created', () => {
+	const language = new Language();
+	assert.ok(language);
+	assert.strictEqual(language.name, null);
+});
+test('Language can set name', () => {
+	const language = new Language();
+	language.name = 'javascript';
+	assert.strictEqual(language.name, 'javascript');
+});
+test('Language can add keyword rules', async () => {
+	const syntax = new Syntax();
+	const language = new Language();
+	const keywords = ['const', 'let', 'var'];
+	language.push(keywords, {type: 'keyword'});
+	// Verify by checking that matches can be found
+	const matches = await language.getMatches(syntax, 'const x = 1;');
+	assert.ok(matches.length > 0);
+	assert.strictEqual(matches[0].expression.type, 'keyword');
+});
+test('Language can add pattern rules', async () => {
+	const syntax = new Syntax();
+	const language = new Language();
+	language.push({
+		pattern: /\/\/.*$/m,
+		type: 'comment'
+	});
+	// Verify by checking that matches can be found
+	const matches = await language.getMatches(syntax, '// this is a comment');
+	assert.ok(matches.length > 0);
+	assert.strictEqual(matches[0].expression.type, 'comment');
+});
+test('Language can get matches from text', async () => {
+	const syntax = new Syntax();
+	const language = new Language();
+	language.push(['const', 'let'], {type: 'keyword'});
+	const code = 'const x = 42;';
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const keywordMatch = matches.find(m => m.type === 'keyword');
+	assert.ok(keywordMatch);
+});

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

@@ -0,0 +1,40 @@
+/**
+ * Tests for Match class
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import {Match} from '../../Syntax/Match.js';
+test('Match can be created with string type', () => {
+	const match = new Match(0, 5, 'keyword');
+	assert.strictEqual(match.offset, 0);
+	assert.strictEqual(match.length, 5);
+	assert.strictEqual(match.type, 'keyword');
+});
+test('Match can be created with expression object', () => {
+	const expression = {type: 'string', owner: null};
+	const match = new Match(10, 8, expression);
+	assert.strictEqual(match.offset, 10);
+	assert.strictEqual(match.length, 8);
+	assert.strictEqual(match.type, 'string');
+	assert.strictEqual(match.expression, expression);
+});
+test('Match stores value', () => {
+	const match = new Match(0, 5, 'keyword', 'const');
+	assert.strictEqual(match.value, 'const');
+});
+test('Match calculates endOffset', () => {
+	const match = new Match(10, 5, 'keyword');
+	assert.strictEqual(match.endOffset, 15);
+});
+test('Match initializes with empty children array', () => {
+	const match = new Match(0, 5, 'keyword');
+	assert.ok(Array.isArray(match.children));
+	assert.strictEqual(match.children.length, 0);
+});

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

@@ -0,0 +1,251 @@
+// Test suite for Syntax/Rule.js
+import Rule from '../../Syntax/Rule.js';
+import {test} from 'node:test';
+import assert from 'node:assert';
+import {JSDOM} from 'jsdom';
+// Setup DOM environment for tests that need document
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.document = dom.window.document;
+test('cStyleComment matches C-style comments', () => {
+	const input = '/* this is a comment */';
+	const match = Rule.cStyleComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '/* this is a comment */');
+});
+test('cStyleComment matches multi-line comments', () => {
+	const input = '/* line 1\nline 2\nline 3 */';
+	const match = Rule.cStyleComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '/* line 1\nline 2\nline 3 */');
+});
+test('cppStyleComment matches C++-style comments', () => {
+	const input = '// this is a comment';
+	const match = Rule.cppStyleComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '// this is a comment');
+});
+test('perlStyleComment matches Perl-style comments', () => {
+	const input = '# this is a comment';
+	const match = Rule.perlStyleComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '# this is a comment');
+});
+test('perlStyleRegularExpression matches Perl regex literals', () => {
+	const input = 'x = /test/g ';
+	const match = Rule.perlStyleRegularExpression.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '/test/g');
+});
+test('rubyStyleRegularExpression matches Ruby regex literals', () => {
+	const input = 'x = /test/i do';
+	const match = Rule.rubyStyleRegularExpression.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '/test/i');
+});
+test('camelCaseType matches CamelCase types', () => {
+	const input = 'MyClass';
+	const match = Rule.camelCaseType.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], 'MyClass');
+});
+test('cStyleType matches C-style type names', () => {
+	const input = 'size_t';
+	const match = Rule.cStyleType.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], 'size_t');
+});
+test('xmlComment matches XML comments', () => {
+	const input = '<!-- this is a comment -->';
+	const match = Rule.xmlComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '<!-- this is a comment -->');
+});
+test('xmlComment matches HTML entity-encoded comments', () => {
+	const input = '&lt;!-- comment --&gt;';
+	const match = Rule.xmlComment.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '&lt;!-- comment --&gt;');
+});
+test('webLink matches HTTP URLs', () => {
+	const input = 'Visit https://example.com/path?query=value';
+	const match = Rule.webLink.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], 'https://example.com/path?query=value');
+});
+test('webLink matches FTP URLs', () => {
+	const input = 'ftp://files.example.com/';
+	const match = Rule.webLink.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], 'ftp://files.example.com/');
+});
+test('hexNumber matches hexadecimal numbers', () => {
+	const input = 'value = 0xFF00AB';
+	const match = Rule.hexNumber.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '0xFF00AB');
+});
+test('decimalNumber matches integers', () => {
+	const input = 'count = 42';
+	const match = Rule.decimalNumber.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '42');
+});
+test('decimalNumber matches floats', () => {
+	const input = 'pi = 3.14159';
+	const match = Rule.decimalNumber.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '3.14159');
+});
+test('decimalNumber matches scientific notation', () => {
+	const input = 'mass = 6.022e23';
+	const match = Rule.decimalNumber.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '6.022e23');
+});
+test('decimalNumber matches negative numbers', () => {
+	const input = 'temp = -273.15';
+	const match = Rule.decimalNumber.pattern.exec(input);
+	assert.ok(match);
+	// Note: The regex has \b at the start, so it won't match the leading -
+	// It matches the number part after the minus
+	assert.strictEqual(match[0], '273.15');
+});
+test('doubleQuotedString matches double-quoted strings', () => {
+	const input = '"hello world"';
+	const match = Rule.doubleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '"hello world"');
+});
+test('doubleQuotedString matches strings with escaped quotes', () => {
+	const input = '"say \\"hello\\""';
+	const match = Rule.doubleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '"say \\"hello\\""');
+});
+test('singleQuotedString matches single-quoted strings', () => {
+	const input = "'hello world'";
+	const match = Rule.singleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], "'hello world'");
+});
+test('singleQuotedString matches strings with escaped quotes', () => {
+	const input = "'it\\'s working'";
+	const match = Rule.singleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], "'it\\'s working'");
+});
+test('multiLineDoubleQuotedString matches multi-line strings', () => {
+	const input = '"line 1\nline 2"';
+	const match = Rule.multiLineDoubleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '"line 1\nline 2"');
+});
+test('multiLineSingleQuotedString matches multi-line strings', () => {
+	const input = "'line 1\nline 2'";
+	const match = Rule.multiLineSingleQuotedString.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], "'line 1\nline 2'");
+});
+test('stringEscape matches backslash escapes', () => {
+	const input = '\\n';
+	const match = Rule.stringEscape.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '\\n');
+});
+test('stringEscape matches escaped quotes', () => {
+	const input = '\\"';
+	const match = Rule.stringEscape.pattern.exec(input);
+	assert.ok(match);
+	assert.strictEqual(match[0], '\\"');
+});
+test('webLinkProcess creates anchor elements', () => {
+	const baseUrl = 'http://docs.example.com/search?q=';
+	const process = Rule.webLinkProcess(baseUrl);
+	// Create a mock container and match
+	const container = document.createElement('span');
+	container.className = 'function';
+	container.textContent = 'myFunction';
+	const match = {
+		value: 'myFunction',
+		expression: {type: 'function'}
+	};
+	const result = process(container, match, {});
+	assert.strictEqual(result.tagName, 'A');
+	assert.strictEqual(result.className, 'function');
+	assert.strictEqual(result.textContent, 'myFunction');
+	assert.ok(result.href.includes('docs.example.com'));
+	assert.ok(result.href.includes('myFunction'));
+});
+test('webLinkProcess encodes URLs properly', () => {
+	const baseUrl = 'http://docs.example.com/search?q=';
+	const process = Rule.webLinkProcess(baseUrl);
+	const container = document.createElement('span');
+	container.className = 'function';
+	container.textContent = 'my Function';
+	const match = {
+		value: 'my Function',
+		expression: {type: 'function'}
+	};
+	const result = process(container, match, {});
+	// Should encode the space
+	assert.ok(result.href.includes('my%20Function'));
+});
+test('webLinkProcess preserves nested HTML', () => {
+	const baseUrl = 'http://docs.example.com/';
+	const process = Rule.webLinkProcess(baseUrl);
+	const container = document.createElement('span');
+	container.className = 'function';
+	container.innerHTML = 'my<span class="highlight">Func</span>tion';
+	const match = {
+		value: 'myFunction',
+		expression: {type: 'function'}
+	};
+	const result = process(container, match, {});
+	assert.strictEqual(result.tagName, 'A');
+	assert.strictEqual(
+		result.innerHTML,
+		'my<span class="highlight">Func</span>tion'
+	);
+	assert.strictEqual(result.className, 'function');
+});

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

@@ -0,0 +1,38 @@
+/**
+ * Tests for Syntax class
+ */
+import {test} from 'node:test';
+import assert from 'node:assert';
+import Syntax from '../Syntax.js';
+test('Syntax class can be instantiated', () => {
+	const syntax = new Syntax();
+	assert.ok(syntax instanceof Syntax);
+});
+test('Syntax.default returns a singleton instance', () => {
+	const instance1 = Syntax.default;
+	const instance2 = Syntax.default;
+	assert.strictEqual(instance1, instance2);
+});
+test('Syntax can register languages', async () => {
+	const syntax = new Syntax();
+	const mockLanguage = {type: 'test'};
+	syntax.register('test', mockLanguage);
+	assert.strictEqual(await syntax.getLanguage('test'), mockLanguage);
+});
+test('Syntax can register aliases', async () => {
+	const syntax = new Syntax();
+	const mockLanguage = {type: 'javascript'};
+	syntax.register('javascript', mockLanguage);
+	syntax.alias('javascript', ['js', 'jsx']);
+	assert.strictEqual(await syntax.getLanguage('js'), mockLanguage);
+	assert.strictEqual(await syntax.getLanguage('jsx'), mockLanguage);
+	assert.strictEqual(await syntax.getLanguage('javascript'), mockLanguage);
+});

data/public/_components/@socketry/syntax/test/helpers/ast-matcher.js ADDED Viewed

@@ -0,0 +1,90 @@
+/**
+ * Test helpers for AST/token matching
+ */
+import assert from 'node:assert';
+/**
+ * Assert that a specific token type exists in matches at the expected text
+ */
+export function assertToken(code, matches, type, expectedText) {
+	const match = matches.find(
+		m =>
+			m.type === type &&
+			code.substring(m.offset, m.offset + m.length) === expectedText
+	);
+	assert.ok(
+		match,
+		`Expected to find token of type '${type}' with text '${expectedText}'`
+	);
+	return match;
+}
+/**
+ * Assert that a specific token type exists in matches
+ */
+export function assertTokenType(matches, type) {
+	const match = matches.find(m => m.type === type);
+	assert.ok(match, `Expected to find token of type '${type}'`);
+	return match;
+}
+/**
+ * Assert that code contains a token of given type at specific position
+ */
+export function assertTokenAt(code, matches, type, expectedText, offset) {
+	const match = matches.find(
+		m =>
+			m.type === type &&
+			m.offset === offset &&
+			code.substring(m.offset, m.offset + m.length) === expectedText
+	);
+	assert.ok(
+		match,
+		`Expected to find token of type '${type}' with text '${expectedText}' at offset ${offset}`
+	);
+	return match;
+}
+/**
+ * Get all tokens of a specific type from matches
+ */
+export function getTokensOfType(matches, type) {
+	return matches.filter(m => m.type === type);
+}
+/**
+ * Assert that matches contain at least N tokens of given type
+ */
+export function assertTokenCount(matches, type, minCount) {
+	const tokens = getTokensOfType(matches, type);
+	assert.ok(
+		tokens.length >= minCount,
+		`Expected at least ${minCount} tokens of type '${type}', found ${tokens.length}`
+	);
+	return tokens;
+}
+/**
+ * Extract the text content of a match from source code
+ */
+export function getMatchText(code, match) {
+	return code.substring(match.offset, match.offset + match.length);
+}
+/**
+ * Assert that highlighted HTML output contains expected token classes
+ */
+export function assertHTMLContains(html, tokenType, expectedText) {
+	const innerHTML = html.innerHTML || html.textContent;
+	assert.ok(
+		innerHTML.includes(tokenType),
+		`Expected HTML to contain token type '${tokenType}'`
+	);
+	if (expectedText) {
+		assert.ok(
+			innerHTML.includes(expectedText),
+			`Expected HTML to contain text '${expectedText}'`
+		);
+	}
+}

data/public/_components/@socketry/syntax/themes/base/apache.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for Apache (empty by default). */

data/public/_components/@socketry/syntax/themes/base/applescript.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for AppleScript (empty by default). */

data/public/_components/@socketry/syntax/themes/base/assembly.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for Assembly (empty by default). */

data/public/_components/@socketry/syntax/themes/base/bash.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for Bash (empty by default). */

data/public/_components/@socketry/syntax/themes/base/basic.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for BASIC (empty by default). */

data/public/_components/@socketry/syntax/themes/base/c.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for C (empty by default). */

data/public/_components/@socketry/syntax/themes/base/clang.css ADDED Viewed

File without changes

data/public/_components/@socketry/syntax/themes/base/csharp.css ADDED Viewed

	@@ -0,0 +1 @@
1	+ /* Per-language overrides for C# (empty by default). */

data/public/_components/@socketry/syntax/themes/base/css.css ADDED Viewed

@@ -0,0 +1,22 @@
+/* Per-language overrides for CSS (empty by default). */
+/* Color box styling */
+.colour-box {
+	display: inline-block;
+	margin: 0 0.2em;
+	border: 1px solid #999;
+	line-height: 0.9;
+	vertical-align: middle;
+}
+.colour-box .sample {
+	display: inline-block;
+	width: 0.9em;
+	height: 0.9em;
+}
+@media (prefers-color-scheme: dark) {
+	.colour-box {
+		border-color: #666;
+	}
+}